@codingame/monaco-editor-wrapper 2.3.0 → 3.0.0

package/dist/main.js

@@ -1,22 +1,4354 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 export { monaco };
-export { b as createEditor, d as defineVSCodeTheme, i as getMonacoLanguage, f as getThemeData, e as getThemes, m as hideCodeWithoutDecoration, l as loadLanguage, k as lockCodeWithoutDecoration, j as registerEditorOpenHandler, r as registerTextModelContentProvider, u as updateEditorKeybindingsMode, h as updateKeybindings } from './index.js';
-export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations } from './index2.js';
+import { e as extensions, _ as _objectSpread2, a as _defineProperty, g as getConfiguration } from './index.js';
+export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, b as registerDefaultConfigurations } from './index.js';
+import getLanguagesServiceOverride, { setLanguages } from 'vscode/service-override/languages';
+import getLanguageConfigurationServiceOverride, { setLanguageConfiguration } from 'vscode/service-override/languageConfiguration';
+import { StandaloneServices, ILanguageService, ITextModelService } from 'vscode/services';
+import getTextmateServiceOverride, { setGrammars } from 'vscode/service-override/textmate';
+import geTokenClassificationServiceOverride, { setTokenTypes, setTokenModifiers, setTokenStyleDefaults } from 'vscode/service-override/tokenClassification';
+import getSnippetConfigurationServiceOverride, { setSnippets } from 'vscode/service-override/snippets';
+import getThemeServiceOverride, { setDefaultThemes, setThemes } from 'vscode/service-override/theme';
+import { registerColor, FoldingController, setCollapseStateForMatchingLines, errorHandler, createConfiguredEditor } from 'vscode/monaco';
+import getModelEditorServiceOverride from 'vscode/service-override/modelEditor';
+import getMessageServiceOverride from 'vscode/service-override/messages';
+import getConfigurationServiceOverride from 'vscode/service-override/configuration';
 export { updateUserConfiguration } from 'vscode/service-override/configuration';
-import './_rollupPluginBabelHelpers.js';
-import 'vscode-oniguruma/release/onig.wasm';
-import 'vscode-oniguruma';
-import 'vscode/service-override/modelEditor';
-import 'vscode/service-override/messages';
+import getKeybindingsServiceOverride, { updateUserKeybindings } from 'vscode/service-override/keybindings';
 import './worker.js';
-import 'vscode/monaco';
+import onigFile from 'vscode-oniguruma/release/onig.wasm';
 import 'monaco-editor/esm/vs/editor/editor.all';
 import 'monaco-editor/esm/vs/editor/standalone/browser/accessibilityHelp/accessibilityHelp';
 import 'monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard';
-import 'monaco-editor/esm/vs/editor/standalone/browser/inspectTokens/inspectTokens';
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneHelpQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/referenceSearch/standaloneReferenceSearch';
-import 'vscode/services';
+
+var rawGrammars = [
+  {
+    "language": "clojure",
+    "scopeName": "source.clojure"
+  },
+  {
+    "language": "coffeescript",
+    "scopeName": "source.coffee"
+  },
+  {
+    "language": "c",
+    "scopeName": "source.c"
+  },
+  {
+    "language": "cpp",
+    "scopeName": "source.cpp"
+  },
+  {
+    "scopeName": "source.c.platform"
+  },
+  {
+    "language": "cuda-cpp",
+    "scopeName": "source.cuda-cpp"
+  },
+  {
+    "language": "csharp",
+    "scopeName": "source.cs"
+  },
+  {
+    "language": "css",
+    "scopeName": "source.css",
+    "tokenTypes": {
+      "meta.function.url string.quoted": "other"
+    }
+  },
+  {
+    "language": "fsharp",
+    "scopeName": "source.fsharp"
+  },
+  {
+    "language": "go",
+    "scopeName": "source.go"
+  },
+  {
+    "language": "groovy",
+    "scopeName": "source.groovy"
+  },
+  {
+    "scopeName": "text.html.basic",
+    "embeddedLanguages": {
+      "text.html": "html",
+      "source.css": "css",
+      "source.js": "javascript",
+      "source.python": "python",
+      "source.smarty": "smarty"
+    },
+    "tokenTypes": {
+      "meta.tag string.quoted": "other"
+    }
+  },
+  {
+    "language": "html",
+    "scopeName": "text.html.derivative",
+    "embeddedLanguages": {
+      "text.html": "html",
+      "source.css": "css",
+      "source.js": "javascript",
+      "source.python": "python",
+      "source.smarty": "smarty"
+    },
+    "tokenTypes": {
+      "meta.tag string.quoted": "other"
+    }
+  },
+  {
+    "language": "java",
+    "scopeName": "source.java"
+  },
+  {
+    "language": "javascriptreact",
+    "scopeName": "source.js.jsx",
+    "embeddedLanguages": {
+      "meta.tag.js": "jsx-tags",
+      "meta.tag.without-attributes.js": "jsx-tags",
+      "meta.tag.attributes.js.jsx": "javascriptreact",
+      "meta.embedded.expression.js": "javascriptreact"
+    },
+    "tokenTypes": {
+      "meta.template.expression": "other",
+      "meta.template.expression string": "string",
+      "meta.template.expression comment": "comment",
+      "entity.name.type.instance.jsdoc": "other",
+      "entity.name.function.tagged-template": "other",
+      "meta.import string.quoted": "other",
+      "variable.other.jsdoc": "other"
+    }
+  },
+  {
+    "language": "javascript",
+    "scopeName": "source.js",
+    "embeddedLanguages": {
+      "meta.tag.js": "jsx-tags",
+      "meta.tag.without-attributes.js": "jsx-tags",
+      "meta.tag.attributes.js": "javascript",
+      "meta.embedded.expression.js": "javascript"
+    },
+    "tokenTypes": {
+      "meta.template.expression": "other",
+      "meta.template.expression string": "string",
+      "meta.template.expression comment": "comment",
+      "entity.name.type.instance.jsdoc": "other",
+      "entity.name.function.tagged-template": "other",
+      "meta.import string.quoted": "other",
+      "variable.other.jsdoc": "other"
+    }
+  },
+  {
+    "scopeName": "source.js.regexp"
+  },
+  {
+    "language": "json",
+    "scopeName": "source.json"
+  },
+  {
+    "language": "jsonc",
+    "scopeName": "source.json.comments"
+  },
+  {
+    "language": "lua",
+    "scopeName": "source.lua",
+    "tokenTypes": {
+      "comment.line.double-dash.doc.lua": "other"
+    }
+  },
+  {
+    "language": "markdown",
+    "scopeName": "text.html.markdown",
+    "embeddedLanguages": {
+      "meta.embedded.block.html": "html",
+      "source.js": "javascript",
+      "source.css": "css",
+      "meta.embedded.block.frontmatter": "yaml",
+      "meta.embedded.block.css": "css",
+      "meta.embedded.block.ini": "ini",
+      "meta.embedded.block.java": "java",
+      "meta.embedded.block.lua": "lua",
+      "meta.embedded.block.makefile": "makefile",
+      "meta.embedded.block.perl": "perl",
+      "meta.embedded.block.r": "r",
+      "meta.embedded.block.ruby": "ruby",
+      "meta.embedded.block.php": "php",
+      "meta.embedded.block.sql": "sql",
+      "meta.embedded.block.vs_net": "vs_net",
+      "meta.embedded.block.xml": "xml",
+      "meta.embedded.block.xsl": "xsl",
+      "meta.embedded.block.yaml": "yaml",
+      "meta.embedded.block.dosbatch": "dosbatch",
+      "meta.embedded.block.clojure": "clojure",
+      "meta.embedded.block.coffee": "coffee",
+      "meta.embedded.block.c": "c",
+      "meta.embedded.block.cpp": "cpp",
+      "meta.embedded.block.diff": "diff",
+      "meta.embedded.block.dockerfile": "dockerfile",
+      "meta.embedded.block.go": "go",
+      "meta.embedded.block.groovy": "groovy",
+      "meta.embedded.block.pug": "jade",
+      "meta.embedded.block.javascript": "javascript",
+      "meta.embedded.block.json": "json",
+      "meta.embedded.block.jsonc": "jsonc",
+      "meta.embedded.block.latex": "latex",
+      "meta.embedded.block.less": "less",
+      "meta.embedded.block.objc": "objc",
+      "meta.embedded.block.scss": "scss",
+      "meta.embedded.block.perl6": "perl6",
+      "meta.embedded.block.powershell": "powershell",
+      "meta.embedded.block.python": "python",
+      "meta.embedded.block.rust": "rust",
+      "meta.embedded.block.scala": "scala",
+      "meta.embedded.block.shellscript": "shellscript",
+      "meta.embedded.block.typescript": "typescript",
+      "meta.embedded.block.typescriptreact": "typescriptreact",
+      "meta.embedded.block.csharp": "csharp",
+      "meta.embedded.block.fsharp": "fsharp"
+    }
+  },
+  {
+    "language": "objective-c",
+    "scopeName": "source.objc"
+  },
+  {
+    "language": "perl",
+    "scopeName": "source.perl"
+  },
+  {
+    "language": "perl6",
+    "scopeName": "source.perl.6"
+  },
+  {
+    "language": "php",
+    "scopeName": "source.php"
+  },
+  {
+    "language": "php",
+    "scopeName": "text.html.php",
+    "embeddedLanguages": {
+      "text.html": "html",
+      "source.php": "php",
+      "source.sql": "sql",
+      "text.xml": "xml",
+      "source.js": "javascript",
+      "source.json": "json",
+      "source.css": "css"
+    }
+  },
+  {
+    "language": "powershell",
+    "scopeName": "source.powershell"
+  },
+  {
+    "language": "python",
+    "scopeName": "source.python"
+  },
+  {
+    "scopeName": "source.regexp.python"
+  },
+  {
+    "language": "r",
+    "scopeName": "source.r"
+  },
+  {
+    "language": "ruby",
+    "scopeName": "source.ruby"
+  },
+  {
+    "language": "rust",
+    "scopeName": "source.rust"
+  },
+  {
+    "language": "scss",
+    "scopeName": "source.css.scss"
+  },
+  {
+    "scopeName": "source.sassdoc"
+  },
+  {
+    "language": "shellscript",
+    "scopeName": "source.shell",
+    "balancedBracketScopes": [
+      "*"
+    ],
+    "unbalancedBracketScopes": [
+      "meta.scope.case-pattern.shell"
+    ]
+  },
+  {
+    "language": "sql",
+    "scopeName": "source.sql"
+  },
+  {
+    "language": "swift",
+    "scopeName": "source.swift"
+  },
+  {
+    "language": "typescript",
+    "scopeName": "source.ts",
+    "unbalancedBracketScopes": [
+      "keyword.operator.relational",
+      "storage.type.function.arrow",
+      "keyword.operator.bitwise.shift",
+      "meta.brace.angle",
+      "punctuation.definition.tag"
+    ],
+    "tokenTypes": {
+      "meta.template.expression": "other",
+      "meta.template.expression string": "string",
+      "meta.template.expression comment": "comment",
+      "entity.name.type.instance.jsdoc": "other",
+      "entity.name.function.tagged-template": "other",
+      "meta.import string.quoted": "other",
+      "variable.other.jsdoc": "other"
+    }
+  },
+  {
+    "language": "typescriptreact",
+    "scopeName": "source.tsx",
+    "unbalancedBracketScopes": [
+      "keyword.operator.relational",
+      "storage.type.function.arrow",
+      "keyword.operator.bitwise.shift",
+      "punctuation.definition.tag"
+    ],
+    "embeddedLanguages": {
+      "meta.tag.tsx": "jsx-tags",
+      "meta.tag.without-attributes.tsx": "jsx-tags",
+      "meta.tag.attributes.tsx": "typescriptreact",
+      "meta.embedded.expression.tsx": "typescriptreact"
+    },
+    "tokenTypes": {
+      "meta.template.expression": "other",
+      "meta.template.expression string": "string",
+      "meta.template.expression comment": "comment",
+      "entity.name.type.instance.jsdoc": "other",
+      "entity.name.function.tagged-template": "other",
+      "meta.import string.quoted": "other",
+      "variable.other.jsdoc": "other"
+    }
+  },
+  {
+    "scopeName": "documentation.injection.ts",
+    "injectTo": [
+      "source.ts",
+      "source.tsx"
+    ]
+  },
+  {
+    "scopeName": "documentation.injection.js.jsx",
+    "injectTo": [
+      "source.js",
+      "source.js.jsx"
+    ]
+  },
+  {
+    "language": "vb",
+    "scopeName": "source.asp.vb.net"
+  },
+  {
+    "language": "xml",
+    "scopeName": "text.xml"
+  },
+  {
+    "language": "xsl",
+    "scopeName": "text.xml.xsl"
+  },
+  {
+    "language": "dockercompose",
+    "scopeName": "source.yaml"
+  },
+  {
+    "language": "yaml",
+    "scopeName": "source.yaml"
+  },
+  {
+    "scopeName": "inline-template.ng",
+    "injectTo": [
+      "source.ts"
+    ],
+    "embeddedLanguages": {
+      "text.html": "html",
+      "source.css": "css",
+      "source.js": "javascript"
+    }
+  },
+  {
+    "scopeName": "inline-styles.ng",
+    "injectTo": [
+      "source.ts"
+    ],
+    "embeddedLanguages": {
+      "source.css": "css"
+    }
+  },
+  {
+    "scopeName": "template.ng",
+    "injectTo": [
+      "text.html.derivative",
+      "source.ts"
+    ],
+    "embeddedLanguages": {
+      "text.html": "html",
+      "source.css": "css"
+    }
+  },
+  {
+    "scopeName": "expression.ng"
+  },
+  {
+    "language": "d",
+    "scopeName": "source.d"
+  },
+  {
+    "language": "dscript",
+    "scopeName": "source.dscript"
+  },
+  {
+    "language": "dml",
+    "scopeName": "source.dml"
+  },
+  {
+    "language": "sdl",
+    "scopeName": "source.sdl"
+  },
+  {
+    "language": "diet",
+    "scopeName": "source.diet"
+  },
+  {
+    "language": "d-injection",
+    "scopeName": "markdown.d.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.d": "d"
+    }
+  },
+  {
+    "language": "dart",
+    "scopeName": "source.dart"
+  },
+  {
+    "language": "haskell",
+    "scopeName": "source.haskell"
+  },
+  {
+    "language": "cabal",
+    "scopeName": "source.cabal"
+  },
+  {
+    "language": "literate haskell",
+    "scopeName": "text.tex.latex.haskell"
+  },
+  {
+    "scopeName": "markdown.haskell.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.haskell": "haskell"
+    }
+  },
+  {
+    "scopeName": "markdown.lhaskell.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.lhaskell": "lhaskell"
+    }
+  },
+  {
+    "scopeName": "markdown.cabal.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.cabal": "cabal"
+    }
+  },
+  {
+    "language": "kotlin",
+    "scopeName": "source.kotlin"
+  },
+  {
+    "language": "kotlinscript",
+    "scopeName": "source.kotlin"
+  },
+  {
+    "scopeName": "markdown.kotlin.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.kotlin": "kotlin"
+    }
+  },
+  {
+    "language": "dune",
+    "scopeName": "source.dune"
+  },
+  {
+    "language": "dune-project",
+    "scopeName": "source.dune-project"
+  },
+  {
+    "language": "dune-workspace",
+    "scopeName": "source.dune-workspace"
+  },
+  {
+    "language": "ocaml.merlin",
+    "scopeName": "source.ocaml.merlin"
+  },
+  {
+    "scopeName": "markdown.ocaml.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.ocaml": "ocaml"
+    }
+  },
+  {
+    "language": "ocaml",
+    "scopeName": "source.ocaml"
+  },
+  {
+    "language": "ocaml.interface",
+    "scopeName": "source.ocaml.interface"
+  },
+  {
+    "language": "ocaml.ocamlbuild",
+    "scopeName": "source.ocaml.ocamlbuild"
+  },
+  {
+    "language": "ocaml.ocamldoc",
+    "scopeName": "source.ocaml.ocamldoc"
+  },
+  {
+    "language": "ocaml.ocamlformat",
+    "scopeName": "source.ocaml.ocamlformat"
+  },
+  {
+    "language": "ocaml.ocamllex",
+    "scopeName": "source.ocaml.ocamllex"
+  },
+  {
+    "scopeName": "source.action.menhir",
+    "injectTo": [
+      "source.ocaml"
+    ]
+  },
+  {
+    "language": "ocaml.menhir",
+    "scopeName": "source.ocaml.menhir",
+    "embeddedLanguages": {
+      "source.embedded-action.menhir": "source.action.menhir"
+    }
+  },
+  {
+    "language": "ocaml.opam",
+    "scopeName": "source.ocaml.opam"
+  },
+  {
+    "language": "ocaml.opam-install",
+    "scopeName": "source.ocaml.opam-install"
+  },
+  {
+    "language": "ocaml.META",
+    "scopeName": "source.ocaml.META"
+  },
+  {
+    "language": "ocaml.oasis",
+    "scopeName": "source.ocaml.oasis"
+  },
+  {
+    "language": "atd",
+    "scopeName": "source.atd"
+  },
+  {
+    "scopeName": "markdown.reason.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.reason": "reason"
+    }
+  },
+  {
+    "language": "cram",
+    "scopeName": "source.cram"
+  },
+  {
+    "language": "pascal",
+    "scopeName": "source.pascal"
+  },
+  {
+    "language": "scala",
+    "scopeName": "source.scala"
+  },
+  {
+    "language": "javap-verbose",
+    "scopeName": "source.jvm-bytecode-verbose"
+  },
+  {
+    "language": "javap",
+    "scopeName": "source.jvm-bytecode"
+  },
+  {
+    "language": "tasty",
+    "scopeName": "source.tasty"
+  },
+  {
+    "language": "buildtarget",
+    "scopeName": "source.buildtarget"
+  },
+  {
+    "language": "COBOL",
+    "scopeName": "source.cobol",
+    "embeddedLanguages": {
+      "meta.embedded.block.sql": "sql",
+      "meta.embedded.block.html": "html"
+    }
+  },
+  {
+    "language": "COBOL Copybook",
+    "scopeName": "source.cobol",
+    "embeddedLanguages": {
+      "meta.embedded.block.sql": "sql",
+      "meta.embedded.block.html": "html"
+    }
+  },
+  {
+    "language": "elixir",
+    "scopeName": "source.elixir"
+  },
+  {
+    "language": "Eex",
+    "scopeName": "text.elixir"
+  },
+  {
+    "language": "HTML (Eex)",
+    "scopeName": "text.html.elixir"
+  },
+  {
+    "language": "erlang",
+    "scopeName": "source.erlang"
+  },
+  {
+    "language": "tcl",
+    "scopeName": "source.tcl"
+  },
+  {
+    "language": "systemverilog",
+    "scopeName": "source.systemverilog"
+  },
+  {
+    "language": "verilog",
+    "scopeName": "source.systemverilog"
+  },
+  {
+    "scopeName": "markdown.verilog.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.systemverilog": "source.systemverilog",
+      "meta.embedded.block.verilog": "source.verilog"
+    }
+  },
+  {
+    "language": "postgres",
+    "scopeName": "source.pgsql"
+  },
+  {
+    "language": "aspnetcorerazor",
+    "scopeName": "text.aspnetcorerazor"
+  },
+  {
+    "language": "pip-requirements",
+    "scopeName": "source.pip-requirements"
+  },
+  {
+    "language": "r",
+    "scopeName": "source.r"
+  },
+  {
+    "language": "rd",
+    "scopeName": "text.tex.latex.rd"
+  },
+  {
+    "language": "debian-control.r",
+    "scopeName": "debian-control.r",
+    "embeddedLanguages": {
+      "meta.embedded.block.r": "r"
+    }
+  },
+  {
+    "language": "rmd",
+    "scopeName": "text.html.rmarkdown",
+    "embeddedLanguages": {
+      "meta.embedded.block.html": "html",
+      "source.js": "javascript",
+      "source.css": "css",
+      "meta.embedded.block.frontmatter": "yaml",
+      "meta.embedded.block.css": "css",
+      "meta.embedded.block.ini": "ini",
+      "meta.embedded.block.java": "java",
+      "meta.embedded.block.lua": "lua",
+      "meta.embedded.block.makefile": "makefile",
+      "meta.embedded.block.perl": "perl",
+      "meta.embedded.block.r": "r",
+      "meta.embedded.block.ruby": "ruby",
+      "meta.embedded.block.php": "php",
+      "meta.embedded.block.sql": "sql",
+      "meta.embedded.block.vs_net": "vs_net",
+      "meta.embedded.block.xml": "xml",
+      "meta.embedded.block.xsl": "xsl",
+      "meta.embedded.block.yaml": "yaml",
+      "meta.embedded.block.dosbatch": "dosbatch",
+      "meta.embedded.block.clojure": "clojure",
+      "meta.embedded.block.coffee": "coffee",
+      "meta.embedded.block.c": "c",
+      "meta.embedded.block.cpp": "cpp",
+      "meta.embedded.block.diff": "diff",
+      "meta.embedded.block.dockerfile": "dockerfile",
+      "meta.embedded.block.go": "go",
+      "meta.embedded.block.groovy": "groovy",
+      "meta.embedded.block.pug": "jade",
+      "meta.embedded.block.javascript": "javascript",
+      "meta.embedded.block.json": "json",
+      "meta.embedded.block.less": "less",
+      "meta.embedded.block.objc": "objc",
+      "meta.embedded.block.scss": "scss",
+      "meta.embedded.block.perl6": "perl6",
+      "meta.embedded.block.powershell": "powershell",
+      "meta.embedded.block.python": "python",
+      "meta.embedded.block.rust": "rust",
+      "meta.embedded.block.scala": "scala",
+      "meta.embedded.block.shellscript": "shellscript",
+      "meta.embedded.block.typescript": "typescript",
+      "meta.embedded.block.typescriptreact": "typescriptreact",
+      "meta.embedded.block.csharp": "csharp",
+      "meta.embedded.block.fsharp": "fsharp"
+    }
+  },
+  {
+    "scopeName": "text.html.markdown.redcarpet",
+    "injectTo": [
+      "text.html.rmarkdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.c": "c",
+      "meta.embedded.block.cpp": "cpp",
+      "meta.embedded.block.r": "r",
+      "meta.embedded.block.yaml": "yaml"
+    }
+  },
+  {
+    "scopeName": "comment.block.r",
+    "injectTo": [
+      "source.cpp"
+    ]
+  },
+  {
+    "language": "solidity",
+    "scopeName": "source.solidity"
+  },
+  {
+    "language": "vue",
+    "scopeName": "source.vue",
+    "embeddedLanguages": {
+      "text.html.basic": "html",
+      "text.html.vue-html": "vue-html",
+      "text.jade.slm": "slm",
+      "text.pug": "jade",
+      "text.haml": "haml",
+      "text.slim": "slim",
+      "text.html.liquid": "liquid",
+      "source.css": "css",
+      "source.css.scss": "scss",
+      "source.css.less": "less",
+      "source.css.postcss": "vue-postcss",
+      "source.css.sugarss": "vue-sugarss",
+      "source.sass": "sass",
+      "source.stylus": "stylus",
+      "source.js": "javascript",
+      "source.ts": "typescript",
+      "source.coffee": "coffeescript",
+      "text.html.markdown": "md",
+      "source.yaml": "yaml",
+      "source.json": "json",
+      "source.php": "php",
+      "source.graphql": "graphql"
+    }
+  },
+  {
+    "language": "vue-postcss",
+    "scopeName": "source.css.postcss"
+  },
+  {
+    "language": "vue-sugarss",
+    "scopeName": "source.css.sugarss"
+  },
+  {
+    "language": "vue-html",
+    "scopeName": "text.html.vue-html",
+    "embeddedLanguages": {
+      "source.js": "javascript"
+    }
+  },
+  {
+    "scopeName": "vue.pug.directives",
+    "injectTo": [
+      "source.vue"
+    ]
+  },
+  {
+    "scopeName": "vue.pug.interpolations",
+    "injectTo": [
+      "source.vue"
+    ]
+  },
+  {
+    "scopeName": "markdown.vue.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.vue": "vue"
+    }
+  },
+  {
+    "language": "svelte",
+    "scopeName": "source.svelte",
+    "embeddedLanguages": {
+      "text.html.basic": "html",
+      "text.html.markdown": "markdown",
+      "text.pug": "jade",
+      "source.css": "css",
+      "source.css.less": "less",
+      "source.css.scss": "scss",
+      "source.css.postcss": "postcss",
+      "source.sass": "sass",
+      "source.stylus": "stylus",
+      "source.js": "javascript",
+      "source.ts": "typescript",
+      "source.coffee": "coffeescript"
+    }
+  },
+  {
+    "scopeName": "svelte.pug",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript",
+      "text.pug": "jade"
+    }
+  },
+  {
+    "scopeName": "svelte.pug.tags",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript",
+      "text.pug": "jade"
+    }
+  },
+  {
+    "scopeName": "svelte.pug.dotblock",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript"
+    }
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.svelte": "svelte"
+    }
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock.script",
+    "injectTo": [
+      "text.html.markdown"
+    ]
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock.style",
+    "injectTo": [
+      "text.html.markdown"
+    ]
+  },
+  {
+    "scopeName": "source.css.postcss",
+    "injectTo": [
+      "source.svelte"
+    ]
+  }
+];
+
+// Generated file, do not modify
+
+/* eslint-disable */
+const loader$3 = {
+  'source.clojure': async () => (await import(
+  /* webpackChunkName: "grammar-source-clojure" */
+
+  /* webpackMode: "lazy" */
+  './clojure.tmLanguage.js').then(module => module)).default,
+  'source.coffee': async () => (await import(
+  /* webpackChunkName: "grammar-source-coffee" */
+
+  /* webpackMode: "lazy" */
+  './coffeescript.tmLanguage.js').then(module => module)).default,
+  'source.c': async () => (await import(
+  /* webpackChunkName: "grammar-source-c" */
+
+  /* webpackMode: "lazy" */
+  './c.tmLanguage.js').then(module => module)).default,
+  'source.cpp': async () => (await import(
+  /* webpackChunkName: "grammar-source-cpp" */
+
+  /* webpackMode: "lazy" */
+  './cpp.tmLanguage.js').then(module => module)).default,
+  'source.c.platform': async () => (await import(
+  /* webpackChunkName: "grammar-source-c-platform" */
+
+  /* webpackMode: "lazy" */
+  './platform.tmLanguage.js').then(module => module)).default,
+  'source.cuda-cpp': async () => (await import(
+  /* webpackChunkName: "grammar-source-cuda-cpp" */
+
+  /* webpackMode: "lazy" */
+  './cuda-cpp.tmLanguage.js').then(module => module)).default,
+  'source.cs': async () => (await import(
+  /* webpackChunkName: "grammar-source-cs" */
+
+  /* webpackMode: "lazy" */
+  './csharp.tmLanguage.js').then(module => module)).default,
+  'source.css': async () => (await import(
+  /* webpackChunkName: "grammar-source-css" */
+
+  /* webpackMode: "lazy" */
+  './css.tmLanguage.js').then(module => module)).default,
+  'source.fsharp': async () => (await import(
+  /* webpackChunkName: "grammar-source-fsharp" */
+
+  /* webpackMode: "lazy" */
+  './fsharp.tmLanguage.js').then(module => module)).default,
+  'source.go': async () => (await import(
+  /* webpackChunkName: "grammar-source-go" */
+
+  /* webpackMode: "lazy" */
+  './go.tmLanguage.js').then(module => module)).default,
+  'source.groovy': async () => (await import(
+  /* webpackChunkName: "grammar-source-groovy" */
+
+  /* webpackMode: "lazy" */
+  './groovy.tmLanguage.js').then(module => module)).default,
+  'text.html.basic': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-basic" */
+
+  /* webpackMode: "lazy" */
+  './html.tmLanguage.js').then(module => module)).default,
+  'text.html.derivative': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-derivative" */
+
+  /* webpackMode: "lazy" */
+  './html-derivative.tmLanguage.js').then(module => module)).default,
+  'source.java': async () => (await import(
+  /* webpackChunkName: "grammar-source-java" */
+
+  /* webpackMode: "lazy" */
+  './java.tmLanguage.js').then(module => module)).default,
+  'source.js.jsx': async () => (await import(
+  /* webpackChunkName: "grammar-source-js-jsx" */
+
+  /* webpackMode: "lazy" */
+  './JavaScriptReact.tmLanguage.js').then(module => module)).default,
+  'source.js': async () => (await import(
+  /* webpackChunkName: "grammar-source-js" */
+
+  /* webpackMode: "lazy" */
+  './JavaScript.tmLanguage.js').then(module => module)).default,
+  'source.js.regexp': async () => (await import(
+  /* webpackChunkName: "grammar-source-js-regexp" */
+
+  /* webpackMode: "lazy" */
+  './Regular Expressions (JavaScript).tmLanguage.js').then(module => module)).default,
+  'source.json': async () => (await import(
+  /* webpackChunkName: "grammar-source-json" */
+
+  /* webpackMode: "lazy" */
+  './JSON.tmLanguage.js').then(module => module)).default,
+  'source.json.comments': async () => (await import(
+  /* webpackChunkName: "grammar-source-json-comments" */
+
+  /* webpackMode: "lazy" */
+  './JSONC.tmLanguage.js').then(module => module)).default,
+  'source.lua': async () => (await import(
+  /* webpackChunkName: "grammar-source-lua" */
+
+  /* webpackMode: "lazy" */
+  './lua.tmLanguage.js').then(module => module)).default,
+  'text.html.markdown': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-markdown" */
+
+  /* webpackMode: "lazy" */
+  './markdown.tmLanguage.js').then(module => module)).default,
+  'source.objc': async () => (await import(
+  /* webpackChunkName: "grammar-source-objc" */
+
+  /* webpackMode: "lazy" */
+  './objective-c.tmLanguage.js').then(module => module)).default,
+  'source.perl': async () => (await import(
+  /* webpackChunkName: "grammar-source-perl" */
+
+  /* webpackMode: "lazy" */
+  './perl.tmLanguage.js').then(module => module)).default,
+  'source.perl.6': async () => (await import(
+  /* webpackChunkName: "grammar-source-perl-6" */
+
+  /* webpackMode: "lazy" */
+  './perl6.tmLanguage.js').then(module => module)).default,
+  'source.php': async () => (await import(
+  /* webpackChunkName: "grammar-source-php" */
+
+  /* webpackMode: "lazy" */
+  './php.tmLanguage.js').then(module => module)).default,
+  'text.html.php': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-php" */
+
+  /* webpackMode: "lazy" */
+  './html.tmLanguage2.js').then(module => module)).default,
+  'source.powershell': async () => (await import(
+  /* webpackChunkName: "grammar-source-powershell" */
+
+  /* webpackMode: "lazy" */
+  './powershell.tmLanguage.js').then(module => module)).default,
+  'source.python': async () => (await import(
+  /* webpackChunkName: "grammar-source-python" */
+
+  /* webpackMode: "lazy" */
+  './MagicPython.tmLanguage.js').then(module => module)).default,
+  'source.regexp.python': async () => (await import(
+  /* webpackChunkName: "grammar-source-regexp-python" */
+
+  /* webpackMode: "lazy" */
+  './MagicRegExp.tmLanguage.js').then(module => module)).default,
+  'source.r': async () => (await import(
+  /* webpackChunkName: "grammar-source-r" */
+
+  /* webpackMode: "lazy" */
+  './r2.js').then(module => module)).default,
+  'source.ruby': async () => (await import(
+  /* webpackChunkName: "grammar-source-ruby" */
+
+  /* webpackMode: "lazy" */
+  './ruby.tmLanguage.js').then(module => module)).default,
+  'source.rust': async () => (await import(
+  /* webpackChunkName: "grammar-source-rust" */
+
+  /* webpackMode: "lazy" */
+  './rust.tmLanguage.js').then(module => module)).default,
+  'source.css.scss': async () => (await import(
+  /* webpackChunkName: "grammar-source-css-scss" */
+
+  /* webpackMode: "lazy" */
+  './scss.tmLanguage.js').then(module => module)).default,
+  'source.sassdoc': async () => (await import(
+  /* webpackChunkName: "grammar-source-sassdoc" */
+
+  /* webpackMode: "lazy" */
+  './sassdoc.tmLanguage.js').then(module => module)).default,
+  'source.shell': async () => (await import(
+  /* webpackChunkName: "grammar-source-shell" */
+
+  /* webpackMode: "lazy" */
+  './shell-unix-bash.tmLanguage.js').then(module => module)).default,
+  'source.sql': async () => (await import(
+  /* webpackChunkName: "grammar-source-sql" */
+
+  /* webpackMode: "lazy" */
+  './sql.tmLanguage.js').then(module => module)).default,
+  'source.swift': async () => (await import(
+  /* webpackChunkName: "grammar-source-swift" */
+
+  /* webpackMode: "lazy" */
+  './swift.tmLanguage.js').then(module => module)).default,
+  'source.ts': async () => (await import(
+  /* webpackChunkName: "grammar-source-ts" */
+
+  /* webpackMode: "lazy" */
+  './TypeScript.tmLanguage.js').then(module => module)).default,
+  'source.tsx': async () => (await import(
+  /* webpackChunkName: "grammar-source-tsx" */
+
+  /* webpackMode: "lazy" */
+  './TypeScriptReact.tmLanguage.js').then(module => module)).default,
+  'documentation.injection.ts': async () => (await import(
+  /* webpackChunkName: "grammar-documentation-injection-ts" */
+
+  /* webpackMode: "lazy" */
+  './jsdoc.ts.injection.tmLanguage.js').then(module => module)).default,
+  'documentation.injection.js.jsx': async () => (await import(
+  /* webpackChunkName: "grammar-documentation-injection-js-jsx" */
+
+  /* webpackMode: "lazy" */
+  './jsdoc.js.injection.tmLanguage.js').then(module => module)).default,
+  'source.asp.vb.net': async () => (await import(
+  /* webpackChunkName: "grammar-source-asp-vb-net" */
+
+  /* webpackMode: "lazy" */
+  './asp-vb-net.tmlanguage.js').then(module => module)).default,
+  'text.xml': async () => (await import(
+  /* webpackChunkName: "grammar-text-xml" */
+
+  /* webpackMode: "lazy" */
+  './xml.tmLanguage.js').then(module => module)).default,
+  'text.xml.xsl': async () => (await import(
+  /* webpackChunkName: "grammar-text-xml-xsl" */
+
+  /* webpackMode: "lazy" */
+  './xsl.tmLanguage.js').then(module => module)).default,
+  'source.yaml': async () => (await import(
+  /* webpackChunkName: "grammar-source-yaml" */
+
+  /* webpackMode: "lazy" */
+  './yaml.tmLanguage.js').then(module => module)).default,
+  'inline-template.ng': async () => (await import(
+  /* webpackChunkName: "grammar-inline-template-ng" */
+
+  /* webpackMode: "lazy" */
+  './inline-template.js').then(module => module)).default,
+  'inline-styles.ng': async () => (await import(
+  /* webpackChunkName: "grammar-inline-styles-ng" */
+
+  /* webpackMode: "lazy" */
+  './inline-styles.js').then(module => module)).default,
+  'template.ng': async () => (await import(
+  /* webpackChunkName: "grammar-template-ng" */
+
+  /* webpackMode: "lazy" */
+  './template.js').then(module => module)).default,
+  'expression.ng': async () => (await import(
+  /* webpackChunkName: "grammar-expression-ng" */
+
+  /* webpackMode: "lazy" */
+  './expression.js').then(module => module)).default,
+  'source.d': async () => (await import(
+  /* webpackChunkName: "grammar-source-d" */
+
+  /* webpackMode: "lazy" */
+  './d2.js').then(module => module)).default,
+  'source.dscript': async () => (await import(
+  /* webpackChunkName: "grammar-source-dscript" */
+
+  /* webpackMode: "lazy" */
+  './d2.js').then(module => module)).default,
+  'source.dml': async () => (await import(
+  /* webpackChunkName: "grammar-source-dml" */
+
+  /* webpackMode: "lazy" */
+  './dml2.js').then(module => module)).default,
+  'source.sdl': async () => (await import(
+  /* webpackChunkName: "grammar-source-sdl" */
+
+  /* webpackMode: "lazy" */
+  './sdl2.js').then(module => module)).default,
+  'source.diet': async () => (await import(
+  /* webpackChunkName: "grammar-source-diet" */
+
+  /* webpackMode: "lazy" */
+  './diet2.js').then(module => module)).default,
+  'markdown.d.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-d-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock.js').then(module => module)).default,
+  'source.dart': async () => (await import(
+  /* webpackChunkName: "grammar-source-dart" */
+
+  /* webpackMode: "lazy" */
+  './dart2.js').then(module => module)).default,
+  'source.haskell': async () => (await import(
+  /* webpackChunkName: "grammar-source-haskell" */
+
+  /* webpackMode: "lazy" */
+  './haskell.tmLanguage.js').then(module => module)).default,
+  'source.cabal': async () => (await import(
+  /* webpackChunkName: "grammar-source-cabal" */
+
+  /* webpackMode: "lazy" */
+  './cabal.tmLanguage.js').then(module => module)).default,
+  'text.tex.latex.haskell': async () => (await import(
+  /* webpackChunkName: "grammar-text-tex-latex-haskell" */
+
+  /* webpackMode: "lazy" */
+  './literateHaskell.tmLanguage.js').then(module => module)).default,
+  'markdown.haskell.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-haskell-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock-haskell.js').then(module => module)).default,
+  'markdown.lhaskell.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-lhaskell-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock-literate-haskell.js').then(module => module)).default,
+  'markdown.cabal.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-cabal-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock-cabal.js').then(module => module)).default,
+  'source.kotlin': async () => (await import(
+  /* webpackChunkName: "grammar-source-kotlin" */
+
+  /* webpackMode: "lazy" */
+  './Kotlin.tmLanguage.js').then(module => module)).default,
+  'markdown.kotlin.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-kotlin-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock2.js').then(module => module)).default,
+  'source.dune': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune" */
+
+  /* webpackMode: "lazy" */
+  './dune2.js').then(module => module)).default,
+  'source.dune-project': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune-project" */
+
+  /* webpackMode: "lazy" */
+  './dune-project2.js').then(module => module)).default,
+  'source.dune-workspace': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune-workspace" */
+
+  /* webpackMode: "lazy" */
+  './dune-workspace2.js').then(module => module)).default,
+  'source.ocaml.merlin': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-merlin" */
+
+  /* webpackMode: "lazy" */
+  './merlin.js').then(module => module)).default,
+  'markdown.ocaml.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-ocaml-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-markdown-codeblock.js').then(module => module)).default,
+  'source.ocaml': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml" */
+
+  /* webpackMode: "lazy" */
+  './ocaml2.js').then(module => module)).default,
+  'source.ocaml.interface': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-interface" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.interface2.js').then(module => module)).default,
+  'source.ocaml.ocamlbuild': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamlbuild" */
+
+  /* webpackMode: "lazy" */
+  './ocamlbuild.js').then(module => module)).default,
+  'source.ocaml.ocamldoc': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamldoc" */
+
+  /* webpackMode: "lazy" */
+  './ocamldoc.js').then(module => module)).default,
+  'source.ocaml.ocamlformat': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamlformat" */
+
+  /* webpackMode: "lazy" */
+  './ocamlformat.js').then(module => module)).default,
+  'source.ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamllex" */
+
+  /* webpackMode: "lazy" */
+  './ocamllex.js').then(module => module)).default,
+  'source.action.menhir': async () => (await import(
+  /* webpackChunkName: "grammar-source-action-menhir" */
+
+  /* webpackMode: "lazy" */
+  './menhir-action.js').then(module => module)).default,
+  'source.ocaml.menhir': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-menhir" */
+
+  /* webpackMode: "lazy" */
+  './menhir.js').then(module => module)).default,
+  'source.ocaml.opam': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-opam" */
+
+  /* webpackMode: "lazy" */
+  './opam.js').then(module => module)).default,
+  'source.ocaml.opam-install': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-opam-install" */
+
+  /* webpackMode: "lazy" */
+  './opam-install.js').then(module => module)).default,
+  'source.ocaml.META': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-META" */
+
+  /* webpackMode: "lazy" */
+  './META.js').then(module => module)).default,
+  'source.ocaml.oasis': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-oasis" */
+
+  /* webpackMode: "lazy" */
+  './oasis.js').then(module => module)).default,
+  'source.atd': async () => (await import(
+  /* webpackChunkName: "grammar-source-atd" */
+
+  /* webpackMode: "lazy" */
+  './atd2.js').then(module => module)).default,
+  'markdown.reason.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-reason-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './reason-markdown-codeblock.js').then(module => module)).default,
+  'source.cram': async () => (await import(
+  /* webpackChunkName: "grammar-source-cram" */
+
+  /* webpackMode: "lazy" */
+  './cram.js').then(module => module)).default,
+  'source.pascal': async () => (await import(
+  /* webpackChunkName: "grammar-source-pascal" */
+
+  /* webpackMode: "lazy" */
+  './pascal.tmLanguage.js').then(module => module)).default,
+  'source.scala': async () => (await import(
+  /* webpackChunkName: "grammar-source-scala" */
+
+  /* webpackMode: "lazy" */
+  './Scala.tmLanguage.js').then(module => module)).default,
+  'source.jvm-bytecode-verbose': async () => (await import(
+  /* webpackChunkName: "grammar-source-jvm-bytecode-verbose" */
+
+  /* webpackMode: "lazy" */
+  './jvm-bytecode-verbose.js').then(module => module)).default,
+  'source.jvm-bytecode': async () => (await import(
+  /* webpackChunkName: "grammar-source-jvm-bytecode" */
+
+  /* webpackMode: "lazy" */
+  './jvm-bytecode.js').then(module => module)).default,
+  'source.tasty': async () => (await import(
+  /* webpackChunkName: "grammar-source-tasty" */
+
+  /* webpackMode: "lazy" */
+  './tasty.js').then(module => module)).default,
+  'source.buildtarget': async () => (await import(
+  /* webpackChunkName: "grammar-source-buildtarget" */
+
+  /* webpackMode: "lazy" */
+  './buildtarget.js').then(module => module)).default,
+  'source.cobol': async () => (await import(
+  /* webpackChunkName: "grammar-source-cobol" */
+
+  /* webpackMode: "lazy" */
+  './COBOL.tmLanguage.js').then(module => module)).default,
+  'source.elixir': async () => (await import(
+  /* webpackChunkName: "grammar-source-elixir" */
+
+  /* webpackMode: "lazy" */
+  './elixir2.js').then(module => module)).default,
+  'text.elixir': async () => (await import(
+  /* webpackChunkName: "grammar-text-elixir" */
+
+  /* webpackMode: "lazy" */
+  './eex.js').then(module => module)).default,
+  'text.html.elixir': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-elixir" */
+
+  /* webpackMode: "lazy" */
+  './html (eex)2.js').then(module => module)).default,
+  'source.erlang': async () => (await import(
+  /* webpackChunkName: "grammar-source-erlang" */
+
+  /* webpackMode: "lazy" */
+  './Erlang.plist.js').then(module => module)).default,
+  'source.tcl': async () => (await import(
+  /* webpackChunkName: "grammar-source-tcl" */
+
+  /* webpackMode: "lazy" */
+  './tcl.tmlanguage.yaml.js').then(module => module)).default,
+  'source.systemverilog': async () => (await import(
+  /* webpackChunkName: "grammar-source-systemverilog" */
+
+  /* webpackMode: "lazy" */
+  './systemverilog.tmLanguage.js').then(module => module)).default,
+  'markdown.verilog.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-verilog-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './codeblock3.js').then(module => module)).default,
+  'source.pgsql': async () => (await import(
+  /* webpackChunkName: "grammar-source-pgsql" */
+
+  /* webpackMode: "lazy" */
+  './pgsql.tmLanguage.js').then(module => module)).default,
+  'text.aspnetcorerazor': async () => (await import(
+  /* webpackChunkName: "grammar-text-aspnetcorerazor" */
+
+  /* webpackMode: "lazy" */
+  './aspnetcorerazor.tmLanguage.js').then(module => module)).default,
+  'source.pip-requirements': async () => (await import(
+  /* webpackChunkName: "grammar-source-pip-requirements" */
+
+  /* webpackMode: "lazy" */
+  './pip-requirements.tmLanguage.js').then(module => module)).default,
+  'text.tex.latex.rd': async () => (await import(
+  /* webpackChunkName: "grammar-text-tex-latex-rd" */
+
+  /* webpackMode: "lazy" */
+  './Rd (R Documentation).js').then(module => module)).default,
+  'debian-control.r': async () => (await import(
+  /* webpackChunkName: "grammar-debian-control-r" */
+
+  /* webpackMode: "lazy" */
+  './dcf.js').then(module => module)).default,
+  'text.html.rmarkdown': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-rmarkdown" */
+
+  /* webpackMode: "lazy" */
+  './RMarkdown.js').then(module => module)).default,
+  'text.html.markdown.redcarpet': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-markdown-redcarpet" */
+
+  /* webpackMode: "lazy" */
+  './Markdown Redcarpet.js').then(module => module)).default,
+  'comment.block.r': async () => (await import(
+  /* webpackChunkName: "grammar-comment-block-r" */
+
+  /* webpackMode: "lazy" */
+  './Rcpp.js').then(module => module)).default,
+  'source.solidity': async () => (await import(
+  /* webpackChunkName: "grammar-source-solidity" */
+
+  /* webpackMode: "lazy" */
+  './solidity2.js').then(module => module)).default,
+  'source.vue': async () => (await import(
+  /* webpackChunkName: "grammar-source-vue" */
+
+  /* webpackMode: "lazy" */
+  './vue-generated.js').then(module => module)).default,
+  'source.css.postcss': async () => (await import(
+  /* webpackChunkName: "grammar-source-css-postcss" */
+
+  /* webpackMode: "lazy" */
+  './postcss.src.yaml.js').then(module => module)).default,
+  'source.css.sugarss': async () => (await import(
+  /* webpackChunkName: "grammar-source-css-sugarss" */
+
+  /* webpackMode: "lazy" */
+  './vue-sugarss2.js').then(module => module)).default,
+  'text.html.vue-html': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-vue-html" */
+
+  /* webpackMode: "lazy" */
+  './vue-html.tmLanguage.js').then(module => module)).default,
+  'vue.pug.directives': async () => (await import(
+  /* webpackChunkName: "grammar-vue-pug-directives" */
+
+  /* webpackMode: "lazy" */
+  './directives.tmLanguage.js').then(module => module)).default,
+  'vue.pug.interpolations': async () => (await import(
+  /* webpackChunkName: "grammar-vue-pug-interpolations" */
+
+  /* webpackMode: "lazy" */
+  './interpolations.tmLanguage.js').then(module => module)).default,
+  'markdown.vue.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-vue-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './markdown-vue.js').then(module => module)).default,
+  'source.svelte': async () => (await import(
+  /* webpackChunkName: "grammar-source-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.tmLanguage.src.yaml.js').then(module => module)).default,
+  'svelte.pug': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte.js').then(module => module)).default,
+  'svelte.pug.tags': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug-tags" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte-tags.js').then(module => module)).default,
+  'svelte.pug.dotblock': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug-dotblock" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte-dotblock.js').then(module => module)).default,
+  'markdown.svelte.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte.js').then(module => module)).default,
+  'markdown.svelte.codeblock.script': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock-script" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte-js.js').then(module => module)).default,
+  'markdown.svelte.codeblock.style': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock-style" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte-css.js').then(module => module)).default
+};
+
+setTokenTypes(extensions.semanticTokenTypes);
+setTokenModifiers(extensions.semanticTokenModifiers);
+setTokenStyleDefaults(extensions.semanticTokenScopes);
+
+setGrammars(rawGrammars.map(grammar => _objectSpread2(_objectSpread2({}, grammar), {}, {
+  path: grammar.scopeName + '.json'
+})), async grammar => JSON.stringify(await loader$3[grammar.scopeName]()));
+
+var textMateLanguages = [
+  {
+    "id": "clojure",
+    "aliases": [
+      "Clojure",
+      "clojure"
+    ],
+    "extensions": [
+      ".clj",
+      ".cljs",
+      ".cljc",
+      ".cljx",
+      ".clojure",
+      ".edn"
+    ]
+  },
+  {
+    "id": "coffeescript",
+    "extensions": [
+      ".coffee",
+      ".cson",
+      ".iced"
+    ],
+    "aliases": [
+      "CoffeeScript",
+      "coffeescript",
+      "coffee"
+    ]
+  },
+  {
+    "id": "c",
+    "extensions": [
+      ".c",
+      ".i"
+    ],
+    "aliases": [
+      "C",
+      "c"
+    ]
+  },
+  {
+    "id": "cpp",
+    "extensions": [
+      ".cpp",
+      ".cc",
+      ".cxx",
+      ".c++",
+      ".hpp",
+      ".hh",
+      ".hxx",
+      ".h++",
+      ".h",
+      ".ii",
+      ".ino",
+      ".inl",
+      ".ipp",
+      ".ixx",
+      ".tpp",
+      ".txx",
+      ".hpp.in",
+      ".h.in"
+    ],
+    "aliases": [
+      "C++",
+      "Cpp",
+      "cpp"
+    ]
+  },
+  {
+    "id": "cuda-cpp",
+    "extensions": [
+      ".cu",
+      ".cuh"
+    ],
+    "aliases": [
+      "CUDA C++"
+    ]
+  },
+  {
+    "id": "csharp",
+    "extensions": [
+      ".cs",
+      ".csx",
+      ".cake"
+    ],
+    "aliases": [
+      "C#",
+      "csharp"
+    ]
+  },
+  {
+    "id": "css",
+    "aliases": [
+      "CSS",
+      "css"
+    ],
+    "extensions": [
+      ".css"
+    ],
+    "mimetypes": [
+      "text/css"
+    ]
+  },
+  {
+    "id": "fsharp",
+    "extensions": [
+      ".fs",
+      ".fsi",
+      ".fsx",
+      ".fsscript"
+    ],
+    "aliases": [
+      "F#",
+      "FSharp",
+      "fsharp"
+    ]
+  },
+  {
+    "id": "go",
+    "extensions": [
+      ".go"
+    ],
+    "aliases": [
+      "Go"
+    ]
+  },
+  {
+    "id": "groovy",
+    "aliases": [
+      "Groovy",
+      "groovy"
+    ],
+    "extensions": [
+      ".groovy",
+      ".gvy",
+      ".gradle",
+      ".jenkinsfile",
+      ".nf"
+    ],
+    "filenames": [
+      "Jenkinsfile"
+    ],
+    "filenamePatterns": [
+      "Jenkinsfile.*"
+    ],
+    "firstLine": "^#!.*\\bgroovy\\b"
+  },
+  {
+    "id": "html",
+    "extensions": [
+      ".html",
+      ".htm",
+      ".shtml",
+      ".xhtml",
+      ".xht",
+      ".mdoc",
+      ".jsp",
+      ".asp",
+      ".aspx",
+      ".jshtm",
+      ".volt",
+      ".ejs",
+      ".rhtml"
+    ],
+    "aliases": [
+      "HTML",
+      "htm",
+      "html",
+      "xhtml"
+    ],
+    "mimetypes": [
+      "text/html",
+      "text/x-jshtm",
+      "text/template",
+      "text/ng-template",
+      "application/xhtml+xml"
+    ]
+  },
+  {
+    "id": "java",
+    "extensions": [
+      ".java",
+      ".jav"
+    ],
+    "aliases": [
+      "Java",
+      "java"
+    ]
+  },
+  {
+    "id": "javascriptreact",
+    "aliases": [
+      "JavaScript React",
+      "jsx"
+    ],
+    "extensions": [
+      ".jsx"
+    ]
+  },
+  {
+    "id": "javascript",
+    "aliases": [
+      "JavaScript",
+      "javascript",
+      "js"
+    ],
+    "extensions": [
+      ".js",
+      ".es6",
+      ".mjs",
+      ".cjs",
+      ".pac"
+    ],
+    "filenames": [
+      "jakefile"
+    ],
+    "firstLine": "^#!.*\\bnode",
+    "mimetypes": [
+      "text/javascript"
+    ]
+  },
+  {
+    "id": "jsx-tags",
+    "aliases": []
+  },
+  {
+    "id": "json",
+    "aliases": [
+      "JSON",
+      "json"
+    ],
+    "extensions": [
+      ".json",
+      ".bowerrc",
+      ".jscsrc",
+      ".webmanifest",
+      ".js.map",
+      ".css.map",
+      ".ts.map",
+      ".har",
+      ".jslintrc",
+      ".jsonld",
+      ".geojson",
+      ".ipynb"
+    ],
+    "filenames": [
+      "composer.lock",
+      ".watchmanconfig"
+    ],
+    "mimetypes": [
+      "application/json",
+      "application/manifest+json"
+    ]
+  },
+  {
+    "id": "jsonc",
+    "aliases": [
+      "JSON with Comments"
+    ],
+    "extensions": [
+      ".jsonc",
+      ".eslintrc",
+      ".eslintrc.json",
+      ".jsfmtrc",
+      ".jshintrc",
+      ".swcrc",
+      ".hintrc",
+      ".babelrc"
+    ],
+    "filenames": [
+      "babel.config.json",
+      ".babelrc.json",
+      ".ember-cli"
+    ]
+  },
+  {
+    "id": "lua",
+    "extensions": [
+      ".lua"
+    ],
+    "aliases": [
+      "Lua",
+      "lua"
+    ]
+  },
+  {
+    "id": "markdown",
+    "aliases": [
+      "Markdown",
+      "markdown"
+    ],
+    "extensions": [
+      ".md",
+      ".mkd",
+      ".mdwn",
+      ".mdown",
+      ".markdown",
+      ".markdn",
+      ".mdtxt",
+      ".mdtext",
+      ".workbook"
+    ]
+  },
+  {
+    "id": "objective-c",
+    "extensions": [
+      ".m"
+    ],
+    "aliases": [
+      "Objective-C"
+    ]
+  },
+  {
+    "id": "objective-cpp",
+    "extensions": [
+      ".mm"
+    ],
+    "aliases": [
+      "Objective-C++"
+    ]
+  },
+  {
+    "id": "perl",
+    "aliases": [
+      "Perl",
+      "perl"
+    ],
+    "extensions": [
+      ".pl",
+      ".pm",
+      ".pod",
+      ".t",
+      ".PL",
+      ".psgi"
+    ],
+    "firstLine": "^#!.*\\bperl\\b"
+  },
+  {
+    "id": "perl6",
+    "aliases": [
+      "Perl 6",
+      "perl6"
+    ],
+    "extensions": [
+      ".p6",
+      ".pl6",
+      ".pm6",
+      ".nqp"
+    ],
+    "firstLine": "(^#!.*\\bperl6\\b)|use\\s+v6"
+  },
+  {
+    "id": "php",
+    "extensions": [
+      ".php",
+      ".php4",
+      ".php5",
+      ".phtml",
+      ".ctp"
+    ],
+    "aliases": [
+      "PHP",
+      "php"
+    ],
+    "firstLine": "^#!\\s*/.*\\bphp\\b",
+    "mimetypes": [
+      "application/x-php"
+    ]
+  },
+  {
+    "id": "powershell",
+    "extensions": [
+      ".ps1",
+      ".psm1",
+      ".psd1",
+      ".pssc",
+      ".psrc"
+    ],
+    "aliases": [
+      "PowerShell",
+      "powershell",
+      "ps",
+      "ps1"
+    ],
+    "firstLine": "^#!\\s*/.*\\bpwsh\\b"
+  },
+  {
+    "id": "python",
+    "extensions": [
+      ".py",
+      ".rpy",
+      ".pyw",
+      ".cpy",
+      ".gyp",
+      ".gypi",
+      ".pyi",
+      ".ipy",
+      ".pyt"
+    ],
+    "aliases": [
+      "Python",
+      "py"
+    ],
+    "filenames": [
+      "Snakefile",
+      "SConstruct",
+      "SConscript"
+    ],
+    "firstLine": "^#!\\s*/?.*\\bpython[0-9.-]*\\b"
+  },
+  {
+    "id": "r",
+    "extensions": [
+      ".r",
+      ".rhistory",
+      ".rprofile",
+      ".rt"
+    ],
+    "aliases": [
+      "R",
+      "r"
+    ]
+  },
+  {
+    "id": "ruby",
+    "extensions": [
+      ".rb",
+      ".rbx",
+      ".rjs",
+      ".gemspec",
+      ".rake",
+      ".ru",
+      ".erb",
+      ".podspec",
+      ".rbi"
+    ],
+    "filenames": [
+      "rakefile",
+      "gemfile",
+      "guardfile",
+      "podfile",
+      "capfile",
+      "cheffile",
+      "hobofile",
+      "vagrantfile",
+      "appraisals",
+      "rantfile",
+      "berksfile",
+      "berksfile.lock",
+      "thorfile",
+      "puppetfile",
+      "dangerfile",
+      "brewfile",
+      "fastfile",
+      "appfile",
+      "deliverfile",
+      "matchfile",
+      "scanfile",
+      "snapfile",
+      "gymfile"
+    ],
+    "aliases": [
+      "Ruby",
+      "rb"
+    ],
+    "firstLine": "^#!\\s*/.*\\bruby\\b"
+  },
+  {
+    "id": "rust",
+    "extensions": [
+      ".rs"
+    ],
+    "aliases": [
+      "Rust",
+      "rust"
+    ]
+  },
+  {
+    "id": "scss",
+    "aliases": [
+      "SCSS",
+      "scss"
+    ],
+    "extensions": [
+      ".scss"
+    ],
+    "mimetypes": [
+      "text/x-scss",
+      "text/scss"
+    ]
+  },
+  {
+    "id": "shellscript",
+    "aliases": [
+      "Shell Script",
+      "shellscript",
+      "bash",
+      "sh",
+      "zsh",
+      "ksh",
+      "csh"
+    ],
+    "extensions": [
+      ".sh",
+      ".bash",
+      ".bashrc",
+      ".bash_aliases",
+      ".bash_profile",
+      ".bash_login",
+      ".ebuild",
+      ".profile",
+      ".bash_logout",
+      ".xprofile",
+      ".xsession",
+      ".xsessionrc",
+      ".Xsession",
+      ".zsh",
+      ".zshrc",
+      ".zprofile",
+      ".zlogin",
+      ".zlogout",
+      ".zshenv",
+      ".zsh-theme",
+      ".ksh",
+      ".csh",
+      ".cshrc",
+      ".tcshrc",
+      ".yashrc",
+      ".yash_profile"
+    ],
+    "filenames": [
+      "APKBUILD",
+      "PKGBUILD",
+      ".envrc",
+      ".hushlogin",
+      "zshrc",
+      "zshenv",
+      "zlogin",
+      "zprofile",
+      "zlogout",
+      "bashrc_Apple_Terminal",
+      "zshrc_Apple_Terminal"
+    ],
+    "firstLine": "^#!.*\\b(bash|zsh|sh|ksh|dtksh|pdksh|mksh|ash|dash|yash|sh|csh|jcsh|tcsh|itcsh).*|^#\\s*-\\*-[^*]*mode:\\s*shell-script[^*]*-\\*-",
+    "mimetypes": [
+      "text/x-shellscript"
+    ]
+  },
+  {
+    "id": "sql",
+    "extensions": [
+      ".sql",
+      ".dsql"
+    ],
+    "aliases": [
+      "SQL"
+    ]
+  },
+  {
+    "id": "swift",
+    "aliases": [
+      "Swift",
+      "swift"
+    ],
+    "extensions": [
+      ".swift"
+    ]
+  },
+  {
+    "id": "typescript",
+    "aliases": [
+      "TypeScript",
+      "ts",
+      "typescript"
+    ],
+    "extensions": [
+      ".ts",
+      ".cts",
+      ".mts"
+    ]
+  },
+  {
+    "id": "typescriptreact",
+    "aliases": [
+      "TypeScript React",
+      "tsx"
+    ],
+    "extensions": [
+      ".tsx"
+    ]
+  },
+  {
+    "id": "jsonc",
+    "filenames": [
+      "tsconfig.json",
+      "jsconfig.json"
+    ],
+    "filenamePatterns": [
+      "tsconfig.*.json",
+      "jsconfig.*.json",
+      "tsconfig-*.json",
+      "jsconfig-*.json"
+    ]
+  },
+  {
+    "id": "json",
+    "filenames": [
+      "tsconfig.tsbuildinfo"
+    ]
+  },
+  {
+    "id": "vb",
+    "extensions": [
+      ".vb",
+      ".brs",
+      ".vbs",
+      ".bas",
+      ".vba"
+    ],
+    "aliases": [
+      "Visual Basic",
+      "vb"
+    ]
+  },
+  {
+    "id": "xml",
+    "extensions": [
+      ".xml",
+      ".xsd",
+      ".ascx",
+      ".atom",
+      ".axml",
+      ".axaml",
+      ".bpmn",
+      ".cpt",
+      ".csl",
+      ".csproj",
+      ".csproj.user",
+      ".dita",
+      ".ditamap",
+      ".dtd",
+      ".ent",
+      ".mod",
+      ".dtml",
+      ".fsproj",
+      ".fxml",
+      ".iml",
+      ".isml",
+      ".jmx",
+      ".launch",
+      ".menu",
+      ".mxml",
+      ".nuspec",
+      ".opml",
+      ".owl",
+      ".proj",
+      ".props",
+      ".pt",
+      ".publishsettings",
+      ".pubxml",
+      ".pubxml.user",
+      ".rbxlx",
+      ".rbxmx",
+      ".rdf",
+      ".rng",
+      ".rss",
+      ".shproj",
+      ".storyboard",
+      ".svg",
+      ".targets",
+      ".tld",
+      ".tmx",
+      ".vbproj",
+      ".vbproj.user",
+      ".vcxproj",
+      ".vcxproj.filters",
+      ".wsdl",
+      ".wxi",
+      ".wxl",
+      ".wxs",
+      ".xaml",
+      ".xbl",
+      ".xib",
+      ".xlf",
+      ".xliff",
+      ".xpdl",
+      ".xul",
+      ".xoml"
+    ],
+    "firstLine": "(\\<\\?xml.*)|(\\<svg)|(\\<\\!doctype\\s+svg)",
+    "aliases": [
+      "XML",
+      "xml"
+    ]
+  },
+  {
+    "id": "xsl",
+    "extensions": [
+      ".xsl",
+      ".xslt"
+    ],
+    "aliases": [
+      "XSL",
+      "xsl"
+    ]
+  },
+  {
+    "id": "dockercompose",
+    "aliases": [
+      "Compose",
+      "compose"
+    ],
+    "filenamePatterns": [
+      "compose.yml",
+      "compose.yaml",
+      "compose.*.yml",
+      "compose.*.yaml",
+      "*docker*compose*.yml",
+      "*docker*compose*.yaml"
+    ]
+  },
+  {
+    "id": "yaml",
+    "aliases": [
+      "YAML",
+      "yaml"
+    ],
+    "extensions": [
+      ".yml",
+      ".eyaml",
+      ".eyml",
+      ".yaml",
+      ".cff"
+    ],
+    "firstLine": "^#cloud-config"
+  },
+  {
+    "id": "d",
+    "extensions": [
+      ".d",
+      ".di"
+    ],
+    "aliases": [
+      "D",
+      "Dlang"
+    ],
+    "firstLine": "^#!.*(dub|rdmd)"
+  },
+  {
+    "id": "dpp",
+    "extensions": [
+      ".dpp",
+      ".d++"
+    ],
+    "aliases": [
+      "D++"
+    ]
+  },
+  {
+    "id": "dscript",
+    "aliases": [
+      "arsd.DScript"
+    ],
+    "extensions": [
+      ".dscript",
+      ".ds"
+    ]
+  },
+  {
+    "id": "dml",
+    "aliases": [
+      "DlangUI Markup Language"
+    ],
+    "extensions": [
+      ".dml"
+    ]
+  },
+  {
+    "id": "sdl",
+    "aliases": [
+      "SDL",
+      "Simple Declarative Language"
+    ],
+    "extensions": [
+      ".sdl"
+    ]
+  },
+  {
+    "id": "diet",
+    "aliases": [
+      "Diet"
+    ],
+    "extensions": [
+      ".dt"
+    ]
+  },
+  {
+    "id": "d-injection"
+  },
+  {
+    "id": "dart",
+    "extensions": [
+      ".dart"
+    ],
+    "aliases": [
+      "Dart"
+    ]
+  },
+  {
+    "id": "haskell",
+    "aliases": [
+      "Haskell",
+      "haskell"
+    ],
+    "extensions": [
+      ".hsig",
+      ".hs"
+    ]
+  },
+  {
+    "id": "cabal",
+    "aliases": [
+      "Cabal",
+      "cabal"
+    ],
+    "extensions": [
+      ".cabal"
+    ]
+  },
+  {
+    "id": "literate haskell",
+    "aliases": [
+      "Literate Haskell",
+      "literate Haskell"
+    ],
+    "extensions": [
+      ".lhs"
+    ]
+  },
+  {
+    "id": "yaml",
+    "aliases": [
+      "YAML",
+      "yaml"
+    ],
+    "filenames": [
+      "stack.yaml.lock"
+    ]
+  },
+  {
+    "id": "kotlin",
+    "aliases": [
+      "Kotlin",
+      "kotlin"
+    ],
+    "extensions": [
+      ".kt"
+    ]
+  },
+  {
+    "id": "kotlinscript",
+    "aliases": [
+      "Kotlinscript",
+      "kotlinscript"
+    ],
+    "extensions": [
+      ".kts"
+    ]
+  },
+  {
+    "id": "dune",
+    "aliases": [
+      "dune"
+    ],
+    "extensions": [
+      "dune",
+      "jbuild"
+    ]
+  },
+  {
+    "id": "dune-project",
+    "aliases": [
+      "dune project"
+    ],
+    "extensions": [
+      "dune-project"
+    ]
+  },
+  {
+    "id": "dune-workspace",
+    "aliases": [
+      "dune workspace"
+    ],
+    "filenames": [
+      "dune-workspace"
+    ],
+    "filenamePatterns": [
+      "dune-workspace.*"
+    ]
+  },
+  {
+    "id": "ocaml.merlin",
+    "aliases": [
+      "Merlin",
+      "merlin"
+    ],
+    "extensions": [
+      ".merlin"
+    ]
+  },
+  {
+    "id": "ocaml",
+    "aliases": [
+      "OCaml",
+      "ocaml"
+    ],
+    "extensions": [
+      ".ml",
+      ".eliom",
+      ".ocamlinit"
+    ]
+  },
+  {
+    "id": "ocaml.interface",
+    "aliases": [
+      "OCaml Interface",
+      "ocaml interface"
+    ],
+    "extensions": [
+      ".mli",
+      ".eliomi"
+    ]
+  },
+  {
+    "id": "ocaml.opam",
+    "aliases": [
+      "opam"
+    ],
+    "filenames": [
+      "opam"
+    ],
+    "extensions": [
+      ".opam",
+      ".opam.locked",
+      ".opam.template"
+    ]
+  },
+  {
+    "id": "ocaml.opam-install",
+    "aliases": [
+      "opam install"
+    ],
+    "extensions": [
+      ".install"
+    ]
+  },
+  {
+    "id": "ocaml.META",
+    "aliases": [
+      "META",
+      "meta"
+    ],
+    "filenames": [
+      "META"
+    ]
+  },
+  {
+    "id": "ocaml.ocamlbuild",
+    "aliases": [
+      "OCamlbuild",
+      "ocamlbuild"
+    ],
+    "extensions": [
+      "_tags"
+    ]
+  },
+  {
+    "id": "ocaml.oasis",
+    "aliases": [
+      "OASIS",
+      "oasis"
+    ],
+    "extensions": [
+      "_oasis"
+    ]
+  },
+  {
+    "id": "ocaml.ocamldoc",
+    "aliases": [
+      "OCamldoc",
+      "ocamldoc"
+    ],
+    "extensions": [
+      ".mld"
+    ]
+  },
+  {
+    "id": "ocaml.ocamlformat",
+    "aliases": [
+      "OCamlFormat",
+      "ocamlformat"
+    ],
+    "extensions": [
+      ".ocamlformat"
+    ]
+  },
+  {
+    "id": "ocaml.ocamllex",
+    "aliases": [
+      "OCamllex",
+      "ocamllex"
+    ],
+    "extensions": [
+      ".mll"
+    ]
+  },
+  {
+    "id": "ocaml.menhir",
+    "aliases": [
+      "Menhir",
+      "menhir",
+      "OCamlyacc",
+      "ocamlyacc"
+    ],
+    "extensions": [
+      ".mly"
+    ]
+  },
+  {
+    "id": "atd",
+    "aliases": [
+      "ATD",
+      "atd"
+    ],
+    "extensions": [
+      ".atd"
+    ]
+  },
+  {
+    "id": "reason",
+    "aliases": [
+      "Reason",
+      "reason"
+    ],
+    "extensions": [
+      ".re",
+      ".rei"
+    ]
+  },
+  {
+    "id": "cram",
+    "aliases": [
+      "Cram Test",
+      "Cram",
+      "cram"
+    ],
+    "extensions": [
+      ".t"
+    ]
+  },
+  {
+    "id": "pascal",
+    "aliases": [
+      "Pascal",
+      "pascal"
+    ],
+    "extensions": [
+      ".pas",
+      ".p",
+      ".dfm",
+      ".fmx",
+      ".dpr",
+      ".dpk",
+      ".lfm",
+      ".dpr",
+      ".lpr"
+    ]
+  },
+  {
+    "id": "scala",
+    "aliases": [
+      "Scala",
+      "scala"
+    ],
+    "extensions": [
+      ".scala",
+      ".sbt",
+      ".sc"
+    ]
+  },
+  {
+    "id": "javap-verbose",
+    "extensions": [
+      ".javap-verbose"
+    ]
+  },
+  {
+    "id": "javap",
+    "extensions": [
+      ".javap"
+    ]
+  },
+  {
+    "id": "java",
+    "extensions": [
+      ".cfr"
+    ]
+  },
+  {
+    "id": "tasty",
+    "aliases": [
+      "TASTy",
+      "tasty"
+    ],
+    "extensions": [
+      ".tasty-decoded"
+    ]
+  },
+  {
+    "id": "buildtarget",
+    "extensions": [
+      ".metals-buildtarget"
+    ]
+  },
+  {
+    "id": "COBOL",
+    "extensions": [
+      ".cbl",
+      ".cob",
+      ".cobol"
+    ]
+  },
+  {
+    "id": "COBOL Copybook",
+    "extensions": [
+      ".cpy",
+      ".copy"
+    ],
+    "filenamePatterns": [
+      "**/*copybook*/**"
+    ]
+  },
+  {
+    "id": "elixir",
+    "aliases": [
+      "Elixir",
+      "elixir"
+    ],
+    "extensions": [
+      ".ex",
+      ".exs"
+    ]
+  },
+  {
+    "id": "Eex",
+    "aliases": [
+      "Eex",
+      "eex"
+    ],
+    "extensions": [
+      ".eex"
+    ]
+  },
+  {
+    "id": "HTML (Eex)",
+    "aliases": [
+      "HTML (Eex)"
+    ],
+    "extensions": [
+      ".html.eex"
+    ]
+  },
+  {
+    "id": "erlang",
+    "aliases": [
+      "Erlang",
+      "erlang"
+    ],
+    "extensions": [
+      ".erl",
+      ".hrl",
+      ".xrl",
+      ".yrl",
+      ".es",
+      ".escript",
+      ".app.src",
+      "rebar.config"
+    ]
+  },
+  {
+    "id": "tcl",
+    "aliases": [
+      "Tcl",
+      "tcl"
+    ],
+    "extensions": [
+      ".tcl",
+      ".test"
+    ]
+  },
+  {
+    "id": "systemverilog",
+    "aliases": [
+      "SystemVerilog",
+      "systemverilog",
+      "System Verilog",
+      "Systemverilog"
+    ],
+    "extensions": [
+      ".sv",
+      ".svh"
+    ]
+  },
+  {
+    "id": "verilog",
+    "aliases": [
+      "Verilog",
+      "verilog"
+    ],
+    "extensions": [
+      ".v",
+      ".vh"
+    ]
+  },
+  {
+    "id": "postgres",
+    "extensions": [
+      ".pgsql",
+      ".psql"
+    ],
+    "aliases": [
+      "Postgres"
+    ]
+  },
+  {
+    "id": "java",
+    "extensions": [
+      ".java",
+      ".class"
+    ]
+  },
+  {
+    "filenames": [
+      ".luarc.json"
+    ],
+    "id": "jsonc"
+  },
+  {
+    "id": "aspnetcorerazor",
+    "extensions": [
+      ".cshtml",
+      ".razor"
+    ],
+    "mimetypes": [
+      "text/x-cshtml"
+    ],
+    "aliases": [
+      "ASP.NET Razor"
+    ]
+  },
+  {
+    "aliases": [
+      "Jinja"
+    ],
+    "extensions": [
+      ".j2",
+      ".jinja2"
+    ],
+    "id": "jinja"
+  },
+  {
+    "aliases": [
+      "pip requirements",
+      "requirements.txt"
+    ],
+    "filenamePatterns": [
+      "**/*-requirements.{txt, in}",
+      "**/*-constraints.txt",
+      "**/requirements-*.{txt, in}",
+      "**/constraints-*.txt",
+      "**/requirements/*.{txt,in}",
+      "**/constraints/*.txt"
+    ],
+    "filenames": [
+      "constraints.txt",
+      "requirements.in",
+      "requirements.txt"
+    ],
+    "id": "pip-requirements"
+  },
+  {
+    "filenames": [
+      ".condarc"
+    ],
+    "id": "yaml"
+  },
+  {
+    "filenames": [
+      ".flake8",
+      ".pep8",
+      ".pylintrc",
+      ".pypirc"
+    ],
+    "id": "ini"
+  },
+  {
+    "filenames": [
+      "Pipfile",
+      "poetry.lock"
+    ],
+    "id": "toml"
+  },
+  {
+    "filenames": [
+      "Pipfile.lock"
+    ],
+    "id": "json"
+  },
+  {
+    "id": "r",
+    "extensions": [
+      ".r",
+      ".rhistory",
+      ".rprofile",
+      ".rt"
+    ],
+    "aliases": [
+      "R",
+      "r"
+    ],
+    "firstLine": "^#!/.*\\bRscript\\b"
+  },
+  {
+    "id": "rd",
+    "extensions": [
+      ".rd"
+    ],
+    "aliases": [
+      "R documentation",
+      "r documentation"
+    ]
+  },
+  {
+    "id": "rmd",
+    "extensions": [
+      ".rmd"
+    ],
+    "aliases": [
+      "R Markdown",
+      "r markdown"
+    ]
+  },
+  {
+    "id": "debian-control.r",
+    "extensions": [
+      ".Rproj"
+    ],
+    "aliases": [
+      "R DCF"
+    ],
+    "filenames": [
+      "DESCRIPTION",
+      ".lintr"
+    ]
+  },
+  {
+    "id": "groovy",
+    "extensions": [
+      ".groovy"
+    ],
+    "aliases": [
+      "Groovy"
+    ]
+  },
+  {
+    "id": "solidity",
+    "aliases": [
+      "Solidity",
+      "solidity"
+    ],
+    "extensions": [
+      ".sol"
+    ]
+  },
+  {
+    "id": "vue",
+    "aliases": [
+      "Vue",
+      "vue"
+    ],
+    "extensions": [
+      ".vue"
+    ]
+  },
+  {
+    "id": "vue-html",
+    "aliases": [
+      "Vue-html"
+    ]
+  },
+  {
+    "id": "vue-postcss",
+    "aliases": [
+      "Vue-PostCSS",
+      "Vue-POSTCSS",
+      "vue-postcss"
+    ]
+  },
+  {
+    "id": "vue-sugarss",
+    "aliases": [
+      "Vue-SugarSS",
+      "Vue-SUGARSS",
+      "vue-sugarss"
+    ]
+  },
+  {
+    "id": "svelte",
+    "aliases": [
+      "Svelte",
+      "svelte"
+    ],
+    "extensions": [
+      ".svelte"
+    ]
+  },
+  {
+    "id": "json",
+    "filenames": [
+      ".prettierrc"
+    ]
+  }
+];
+
+// Generated file, do not modify
+
+/* eslint-disable */
+const loader$2 = {
+  'clojure': async () => (await import(
+  /* webpackChunkName: "language-configuration-clojure" */
+
+  /* webpackMode: "lazy" */
+  './clojure.js').then(module => module)).default,
+  'coffeescript': async () => (await import(
+  /* webpackChunkName: "language-configuration-coffeescript" */
+
+  /* webpackMode: "lazy" */
+  './coffeescript.js').then(module => module)).default,
+  'c': async () => (await import(
+  /* webpackChunkName: "language-configuration-c" */
+
+  /* webpackMode: "lazy" */
+  './c.js').then(module => module)).default,
+  'cpp': async () => (await import(
+  /* webpackChunkName: "language-configuration-cpp" */
+
+  /* webpackMode: "lazy" */
+  './cpp.js').then(module => module)).default,
+  'cuda-cpp': async () => (await import(
+  /* webpackChunkName: "language-configuration-cuda-cpp" */
+
+  /* webpackMode: "lazy" */
+  './cuda-cpp.js').then(module => module)).default,
+  'csharp': async () => (await import(
+  /* webpackChunkName: "language-configuration-csharp" */
+
+  /* webpackMode: "lazy" */
+  './csharp.js').then(module => module)).default,
+  'css': async () => (await import(
+  /* webpackChunkName: "language-configuration-css" */
+
+  /* webpackMode: "lazy" */
+  './css.js').then(module => module)).default,
+  'fsharp': async () => (await import(
+  /* webpackChunkName: "language-configuration-fsharp" */
+
+  /* webpackMode: "lazy" */
+  './fsharp.js').then(module => module)).default,
+  'go': async () => (await import(
+  /* webpackChunkName: "language-configuration-go" */
+
+  /* webpackMode: "lazy" */
+  './go.js').then(module => module)).default,
+  'groovy': async () => (await import(
+  /* webpackChunkName: "language-configuration-groovy" */
+
+  /* webpackMode: "lazy" */
+  './groovy.js').then(module => module)).default,
+  'html': async () => (await import(
+  /* webpackChunkName: "language-configuration-html" */
+
+  /* webpackMode: "lazy" */
+  './html.js').then(module => module)).default,
+  'java': async () => (await import(
+  /* webpackChunkName: "language-configuration-java" */
+
+  /* webpackMode: "lazy" */
+  './java.js').then(module => module)).default,
+  'javascriptreact': async () => (await import(
+  /* webpackChunkName: "language-configuration-javascriptreact" */
+
+  /* webpackMode: "lazy" */
+  './javascriptreact.js').then(module => module)).default,
+  'javascript': async () => (await import(
+  /* webpackChunkName: "language-configuration-javascript" */
+
+  /* webpackMode: "lazy" */
+  './javascript.js').then(module => module)).default,
+  'jsx-tags': async () => (await import(
+  /* webpackChunkName: "language-configuration-jsx-tags" */
+
+  /* webpackMode: "lazy" */
+  './jsx-tags.js').then(module => module)).default,
+  'json': async () => (await import(
+  /* webpackChunkName: "language-configuration-json" */
+
+  /* webpackMode: "lazy" */
+  './json.js').then(module => module)).default,
+  'jsonc': async () => (await import(
+  /* webpackChunkName: "language-configuration-jsonc" */
+
+  /* webpackMode: "lazy" */
+  './jsonc.js').then(module => module)).default,
+  'lua': async () => (await import(
+  /* webpackChunkName: "language-configuration-lua" */
+
+  /* webpackMode: "lazy" */
+  './lua.js').then(module => module)).default,
+  'markdown': async () => (await import(
+  /* webpackChunkName: "language-configuration-markdown" */
+
+  /* webpackMode: "lazy" */
+  './markdown.js').then(module => module)).default,
+  'objective-c': async () => (await import(
+  /* webpackChunkName: "language-configuration-objective-c" */
+
+  /* webpackMode: "lazy" */
+  './objective-c.js').then(module => module)).default,
+  'objective-cpp': async () => (await import(
+  /* webpackChunkName: "language-configuration-objective-cpp" */
+
+  /* webpackMode: "lazy" */
+  './objective-cpp.js').then(module => module)).default,
+  'perl': async () => (await import(
+  /* webpackChunkName: "language-configuration-perl" */
+
+  /* webpackMode: "lazy" */
+  './perl.js').then(module => module)).default,
+  'perl6': async () => (await import(
+  /* webpackChunkName: "language-configuration-perl6" */
+
+  /* webpackMode: "lazy" */
+  './perl6.js').then(module => module)).default,
+  'php': async () => (await import(
+  /* webpackChunkName: "language-configuration-php" */
+
+  /* webpackMode: "lazy" */
+  './php.js').then(module => module)).default,
+  'powershell': async () => (await import(
+  /* webpackChunkName: "language-configuration-powershell" */
+
+  /* webpackMode: "lazy" */
+  './powershell.js').then(module => module)).default,
+  'python': async () => (await import(
+  /* webpackChunkName: "language-configuration-python" */
+
+  /* webpackMode: "lazy" */
+  './python.js').then(module => module)).default,
+  'r': async () => (await import(
+  /* webpackChunkName: "language-configuration-r" */
+
+  /* webpackMode: "lazy" */
+  './r.js').then(module => module)).default,
+  'ruby': async () => (await import(
+  /* webpackChunkName: "language-configuration-ruby" */
+
+  /* webpackMode: "lazy" */
+  './ruby.js').then(module => module)).default,
+  'rust': async () => (await import(
+  /* webpackChunkName: "language-configuration-rust" */
+
+  /* webpackMode: "lazy" */
+  './rust.js').then(module => module)).default,
+  'scss': async () => (await import(
+  /* webpackChunkName: "language-configuration-scss" */
+
+  /* webpackMode: "lazy" */
+  './scss.js').then(module => module)).default,
+  'shellscript': async () => (await import(
+  /* webpackChunkName: "language-configuration-shellscript" */
+
+  /* webpackMode: "lazy" */
+  './shellscript.js').then(module => module)).default,
+  'sql': async () => (await import(
+  /* webpackChunkName: "language-configuration-sql" */
+
+  /* webpackMode: "lazy" */
+  './sql.js').then(module => module)).default,
+  'swift': async () => (await import(
+  /* webpackChunkName: "language-configuration-swift" */
+
+  /* webpackMode: "lazy" */
+  './swift.js').then(module => module)).default,
+  'typescript': async () => (await import(
+  /* webpackChunkName: "language-configuration-typescript" */
+
+  /* webpackMode: "lazy" */
+  './typescript.js').then(module => module)).default,
+  'typescriptreact': async () => (await import(
+  /* webpackChunkName: "language-configuration-typescriptreact" */
+
+  /* webpackMode: "lazy" */
+  './typescriptreact.js').then(module => module)).default,
+  'vb': async () => (await import(
+  /* webpackChunkName: "language-configuration-vb" */
+
+  /* webpackMode: "lazy" */
+  './vb.js').then(module => module)).default,
+  'xml': async () => (await import(
+  /* webpackChunkName: "language-configuration-xml" */
+
+  /* webpackMode: "lazy" */
+  './xml.js').then(module => module)).default,
+  'xsl': async () => (await import(
+  /* webpackChunkName: "language-configuration-xsl" */
+
+  /* webpackMode: "lazy" */
+  './xsl.js').then(module => module)).default,
+  'dockercompose': async () => (await import(
+  /* webpackChunkName: "language-configuration-dockercompose" */
+
+  /* webpackMode: "lazy" */
+  './dockercompose.js').then(module => module)).default,
+  'yaml': async () => (await import(
+  /* webpackChunkName: "language-configuration-yaml" */
+
+  /* webpackMode: "lazy" */
+  './yaml.js').then(module => module)).default,
+  'd': async () => (await import(
+  /* webpackChunkName: "language-configuration-d" */
+
+  /* webpackMode: "lazy" */
+  './d.js').then(module => module)).default,
+  'dpp': async () => (await import(
+  /* webpackChunkName: "language-configuration-dpp" */
+
+  /* webpackMode: "lazy" */
+  './dpp.js').then(module => module)).default,
+  'dscript': async () => (await import(
+  /* webpackChunkName: "language-configuration-dscript" */
+
+  /* webpackMode: "lazy" */
+  './dscript.js').then(module => module)).default,
+  'dml': async () => (await import(
+  /* webpackChunkName: "language-configuration-dml" */
+
+  /* webpackMode: "lazy" */
+  './dml.js').then(module => module)).default,
+  'sdl': async () => (await import(
+  /* webpackChunkName: "language-configuration-sdl" */
+
+  /* webpackMode: "lazy" */
+  './sdl.js').then(module => module)).default,
+  'diet': async () => (await import(
+  /* webpackChunkName: "language-configuration-diet" */
+
+  /* webpackMode: "lazy" */
+  './diet.js').then(module => module)).default,
+  'dart': async () => (await import(
+  /* webpackChunkName: "language-configuration-dart" */
+
+  /* webpackMode: "lazy" */
+  './dart.js').then(module => module)).default,
+  'haskell': async () => (await import(
+  /* webpackChunkName: "language-configuration-haskell" */
+
+  /* webpackMode: "lazy" */
+  './haskell.js').then(module => module)).default,
+  'cabal': async () => (await import(
+  /* webpackChunkName: "language-configuration-cabal" */
+
+  /* webpackMode: "lazy" */
+  './cabal.js').then(module => module)).default,
+  'literate haskell': async () => (await import(
+  /* webpackChunkName: "language-configuration-literate haskell" */
+
+  /* webpackMode: "lazy" */
+  './literate haskell.js').then(module => module)).default,
+  'kotlin': async () => (await import(
+  /* webpackChunkName: "language-configuration-kotlin" */
+
+  /* webpackMode: "lazy" */
+  './kotlin.js').then(module => module)).default,
+  'kotlinscript': async () => (await import(
+  /* webpackChunkName: "language-configuration-kotlinscript" */
+
+  /* webpackMode: "lazy" */
+  './kotlinscript.js').then(module => module)).default,
+  'dune': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune" */
+
+  /* webpackMode: "lazy" */
+  './dune.js').then(module => module)).default,
+  'dune-project': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune-project" */
+
+  /* webpackMode: "lazy" */
+  './dune-project.js').then(module => module)).default,
+  'dune-workspace': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune-workspace" */
+
+  /* webpackMode: "lazy" */
+  './dune-workspace.js').then(module => module)).default,
+  'ocaml': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.js').then(module => module)).default,
+  'ocaml.interface': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.interface" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.interface.js').then(module => module)).default,
+  'ocaml.opam': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.opam" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.opam.js').then(module => module)).default,
+  'ocaml.opam-install': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.opam-install" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.opam-install.js').then(module => module)).default,
+  'ocaml.META': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.META" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.META.js').then(module => module)).default,
+  'ocaml.ocamlbuild': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamlbuild" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamlbuild.js').then(module => module)).default,
+  'ocaml.oasis': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.oasis" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.oasis.js').then(module => module)).default,
+  'ocaml.ocamlformat': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamlformat" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamlformat.js').then(module => module)).default,
+  'ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamllex" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamllex.js').then(module => module)).default,
+  'ocaml.menhir': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.menhir" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.menhir.js').then(module => module)).default,
+  'atd': async () => (await import(
+  /* webpackChunkName: "language-configuration-atd" */
+
+  /* webpackMode: "lazy" */
+  './atd.js').then(module => module)).default,
+  'reason': async () => (await import(
+  /* webpackChunkName: "language-configuration-reason" */
+
+  /* webpackMode: "lazy" */
+  './reason.js').then(module => module)).default,
+  'pascal': async () => (await import(
+  /* webpackChunkName: "language-configuration-pascal" */
+
+  /* webpackMode: "lazy" */
+  './pascal.js').then(module => module)).default,
+  'scala': async () => (await import(
+  /* webpackChunkName: "language-configuration-scala" */
+
+  /* webpackMode: "lazy" */
+  './scala.js').then(module => module)).default,
+  'COBOL': async () => (await import(
+  /* webpackChunkName: "language-configuration-COBOL" */
+
+  /* webpackMode: "lazy" */
+  './COBOL.js').then(module => module)).default,
+  'COBOL Copybook': async () => (await import(
+  /* webpackChunkName: "language-configuration-COBOL Copybook" */
+
+  /* webpackMode: "lazy" */
+  './COBOL Copybook.js').then(module => module)).default,
+  'elixir': async () => (await import(
+  /* webpackChunkName: "language-configuration-elixir" */
+
+  /* webpackMode: "lazy" */
+  './elixir.js').then(module => module)).default,
+  'HTML (Eex)': async () => (await import(
+  /* webpackChunkName: "language-configuration-HTML (Eex)" */
+
+  /* webpackMode: "lazy" */
+  './HTML (Eex).js').then(module => module)).default,
+  'erlang': async () => (await import(
+  /* webpackChunkName: "language-configuration-erlang" */
+
+  /* webpackMode: "lazy" */
+  './erlang.js').then(module => module)).default,
+  'tcl': async () => (await import(
+  /* webpackChunkName: "language-configuration-tcl" */
+
+  /* webpackMode: "lazy" */
+  './tcl.js').then(module => module)).default,
+  'systemverilog': async () => (await import(
+  /* webpackChunkName: "language-configuration-systemverilog" */
+
+  /* webpackMode: "lazy" */
+  './systemverilog.js').then(module => module)).default,
+  'verilog': async () => (await import(
+  /* webpackChunkName: "language-configuration-verilog" */
+
+  /* webpackMode: "lazy" */
+  './verilog.js').then(module => module)).default,
+  'postgres': async () => (await import(
+  /* webpackChunkName: "language-configuration-postgres" */
+
+  /* webpackMode: "lazy" */
+  './postgres.js').then(module => module)).default,
+  'aspnetcorerazor': async () => (await import(
+  /* webpackChunkName: "language-configuration-aspnetcorerazor" */
+
+  /* webpackMode: "lazy" */
+  './aspnetcorerazor.js').then(module => module)).default,
+  'pip-requirements': async () => (await import(
+  /* webpackChunkName: "language-configuration-pip-requirements" */
+
+  /* webpackMode: "lazy" */
+  './pip-requirements.js').then(module => module)).default,
+  'rd': async () => (await import(
+  /* webpackChunkName: "language-configuration-rd" */
+
+  /* webpackMode: "lazy" */
+  './rd.js').then(module => module)).default,
+  'rmd': async () => (await import(
+  /* webpackChunkName: "language-configuration-rmd" */
+
+  /* webpackMode: "lazy" */
+  './rmd.js').then(module => module)).default,
+  'debian-control.r': async () => (await import(
+  /* webpackChunkName: "language-configuration-debian-control.r" */
+
+  /* webpackMode: "lazy" */
+  './debian-control.r.js').then(module => module)).default,
+  'solidity': async () => (await import(
+  /* webpackChunkName: "language-configuration-solidity" */
+
+  /* webpackMode: "lazy" */
+  './solidity.js').then(module => module)).default,
+  'vue': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue" */
+
+  /* webpackMode: "lazy" */
+  './vue.js').then(module => module)).default,
+  'vue-html': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-html" */
+
+  /* webpackMode: "lazy" */
+  './vue-html.js').then(module => module)).default,
+  'vue-postcss': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-postcss" */
+
+  /* webpackMode: "lazy" */
+  './vue-postcss.js').then(module => module)).default,
+  'vue-sugarss': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-sugarss" */
+
+  /* webpackMode: "lazy" */
+  './vue-sugarss.js').then(module => module)).default,
+  'svelte': async () => (await import(
+  /* webpackChunkName: "language-configuration-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.js').then(module => module)).default
+};
+
+// Generated file, do not modify
+
+/* eslint-disable */
+const loader$1 = {
+  'coffeescript': async () => (await import(
+  /* webpackChunkName: "snippet-coffeescript" */
+
+  /* webpackMode: "lazy" */
+  './coffeescript-coffeescript.code-snippets.js').then(module => module)).default,
+  'c': async () => (await import(
+  /* webpackChunkName: "snippet-c" */
+
+  /* webpackMode: "lazy" */
+  './cpp-c.code-snippets.js').then(module => module)).default,
+  'cpp': async () => (await import(
+  /* webpackChunkName: "snippet-cpp" */
+
+  /* webpackMode: "lazy" */
+  './cpp-cpp.code-snippets.js').then(module => module)).default,
+  'csharp': async () => (await import(
+  /* webpackChunkName: "snippet-csharp" */
+
+  /* webpackMode: "lazy" */
+  './omnisharp-csharp.js').then(module => module)).default,
+  'fsharp': async () => (await import(
+  /* webpackChunkName: "snippet-fsharp" */
+
+  /* webpackMode: "lazy" */
+  './fsharp-fsharp.code-snippets.js').then(module => module)).default,
+  'groovy': async () => (await import(
+  /* webpackChunkName: "snippet-groovy" */
+
+  /* webpackMode: "lazy" */
+  './groovy-groovy.code-snippets.js').then(module => module)).default,
+  'java': async () => (await import(
+  /* webpackChunkName: "snippet-java" */
+
+  /* webpackMode: "lazy" */
+  './java-java.js').then(module => module)).default,
+  'javascript': async () => (await import(
+  /* webpackChunkName: "snippet-javascript" */
+
+  /* webpackMode: "lazy" */
+  './javascript-javascript.code-snippets.js').then(module => module)).default,
+  'javascriptreact': async () => (await import(
+  /* webpackChunkName: "snippet-javascriptreact" */
+
+  /* webpackMode: "lazy" */
+  './javascript-javascript.code-snippets.js').then(module => module)).default,
+  'markdown': async () => (await import(
+  /* webpackChunkName: "snippet-markdown" */
+
+  /* webpackMode: "lazy" */
+  './markdown-basics-markdown.code-snippets.js').then(module => module)).default,
+  'php': async () => (await import(
+  /* webpackChunkName: "snippet-php" */
+
+  /* webpackMode: "lazy" */
+  './php-php.code-snippets.js').then(module => module)).default,
+  'swift': async () => (await import(
+  /* webpackChunkName: "snippet-swift" */
+
+  /* webpackMode: "lazy" */
+  './swift-swift.code-snippets.js').then(module => module)).default,
+  'typescript': async () => (await import(
+  /* webpackChunkName: "snippet-typescript" */
+
+  /* webpackMode: "lazy" */
+  './typescript-basics-typescript.code-snippets.js').then(module => module)).default,
+  'typescriptreact': async () => (await import(
+  /* webpackChunkName: "snippet-typescriptreact" */
+
+  /* webpackMode: "lazy" */
+  './typescript-basics-typescript.code-snippets.js').then(module => module)).default,
+  'vb': async () => (await import(
+  /* webpackChunkName: "snippet-vb" */
+
+  /* webpackMode: "lazy" */
+  './vb-vb.code-snippets.js').then(module => module)).default,
+  'diet': async () => (await import(
+  /* webpackChunkName: "snippet-diet" */
+
+  /* webpackMode: "lazy" */
+  './d-diet.js').then(module => module)).default,
+  'kotlin': async () => (await import(
+  /* webpackChunkName: "snippet-kotlin" */
+
+  /* webpackMode: "lazy" */
+  './kotlin-kotlin.js').then(module => module)).default,
+  'kotlinscript': async () => (await import(
+  /* webpackChunkName: "snippet-kotlinscript" */
+
+  /* webpackMode: "lazy" */
+  './kotlin-kotlin.js').then(module => module)).default,
+  'dune': async () => (await import(
+  /* webpackChunkName: "snippet-dune" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-dune.js').then(module => module)).default,
+  'dune-project': async () => (await import(
+  /* webpackChunkName: "snippet-dune-project" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-dune-project.js').then(module => module)).default,
+  'ocaml': async () => (await import(
+  /* webpackChunkName: "snippet-ocaml" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-ocaml.js').then(module => module)).default,
+  'ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "snippet-ocaml.ocamllex" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-ocamllex.js').then(module => module)).default,
+  'pascal': async () => (await import(
+  /* webpackChunkName: "snippet-pascal" */
+
+  /* webpackMode: "lazy" */
+  './pascal-pascal.js').then(module => module)).default,
+  'COBOL': async () => (await import(
+  /* webpackChunkName: "snippet-COBOL" */
+
+  /* webpackMode: "lazy" */
+  './cobol-snippets.js').then(module => module)).default,
+  'COBOL Copybook': async () => (await import(
+  /* webpackChunkName: "snippet-COBOL Copybook" */
+
+  /* webpackMode: "lazy" */
+  './cobol-snippets.js').then(module => module)).default,
+  'elixir': async () => (await import(
+  /* webpackChunkName: "snippet-elixir" */
+
+  /* webpackMode: "lazy" */
+  './elixir-snippets.js').then(module => module)).default,
+  'erlang': async () => (await import(
+  /* webpackChunkName: "snippet-erlang" */
+
+  /* webpackMode: "lazy" */
+  './erlang-erlang.js').then(module => module)).default,
+  'tcl': async () => (await import(
+  /* webpackChunkName: "snippet-tcl" */
+
+  /* webpackMode: "lazy" */
+  './tcl-tcl.js').then(module => module)).default,
+  'systemverilog': async () => (await import(
+  /* webpackChunkName: "snippet-systemverilog" */
+
+  /* webpackMode: "lazy" */
+  './svlangserver-systemverilog.js').then(module => module)).default,
+  'verilog': async () => (await import(
+  /* webpackChunkName: "snippet-verilog" */
+
+  /* webpackMode: "lazy" */
+  './svlangserver-systemverilog.js').then(module => module)).default,
+  'r': async () => (await import(
+  /* webpackChunkName: "snippet-r" */
+
+  /* webpackMode: "lazy" */
+  './vscode-R-r-snippets.js').then(module => module)).default,
+  'rd': async () => (await import(
+  /* webpackChunkName: "snippet-rd" */
+
+  /* webpackMode: "lazy" */
+  './vscode-R-r-snippets.js').then(module => module)).default,
+  'rmd': async () => (await import(
+  /* webpackChunkName: "snippet-rmd" */
+
+  /* webpackMode: "lazy" */
+  './vscode-R-rmarkdown.js').then(module => module)).default,
+  'solidity': async () => (await import(
+  /* webpackChunkName: "snippet-solidity" */
+
+  /* webpackMode: "lazy" */
+  './solidity-solidity.js').then(module => module)).default,
+  'svelte': async () => (await import(
+  /* webpackChunkName: "snippet-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.svelte-vscode-svelte.js').then(module => module)).default
+};
+
+setSnippets(Object.keys(loader$1).map(language => ({
+  language,
+  path: "".concat(language, "-snippets.json")
+})), async extensionPoint => JSON.stringify(await loader$1[extensionPoint.language]()));
+
+/* Add custom blocks parsing (for tech.io):
+// { [autofold]
+//  custom block content
+// }
+*/
+const CUSTOM_BLOCK_BEGIN_REGEX = '^\\s*(?:\\/\\/|#).*(?:\\{|#region)';
+const CUSTOM_BLOCK_END_REGEX = '^\\s*(?:\\/\\/|#).*(?:\\}|#endregion)';
+
+function regexOr(regex, add) {
+  if (regex == null) {
+    return add;
+  } else if (typeof regex === 'string') {
+    return "(?:".concat(regex, ")|(?:").concat(add, ")");
+  } else {
+    return {
+      flags: regex.flags,
+      pattern: regexOr(regex.pattern, add)
+    };
+  }
+}
+
+function addCustomFoldingMarkers(configuration) {
+  var _configuration$foldin, _configuration$foldin2;
+
+  const markers = (_configuration$foldin = configuration.folding) === null || _configuration$foldin === void 0 ? void 0 : _configuration$foldin.markers;
+  return _objectSpread2(_objectSpread2({}, configuration), {}, {
+    folding: _objectSpread2(_objectSpread2({}, (_configuration$foldin2 = configuration.folding) !== null && _configuration$foldin2 !== void 0 ? _configuration$foldin2 : {}), {}, {
+      markers: {
+        start: regexOr(markers === null || markers === void 0 ? void 0 : markers.start, CUSTOM_BLOCK_BEGIN_REGEX),
+        end: regexOr(markers === null || markers === void 0 ? void 0 : markers.end, CUSTOM_BLOCK_END_REGEX)
+      }
+    })
+  });
+}
+
+const customAliases = {
+  csharp: ['c#'],
+  'objective-c': ['objectivec', 'objc'],
+  python: ['datascience-python', 'python3'],
+  r: ['datascience-r'],
+  vb: ['vb.net'],
+  javascriptreact: ['react'],
+  javascript: ['vue', 'node'],
+  typescript: ['angular'],
+  sql: ['mysql'],
+  postgres: ['postgresql', 'postgres', 'pg', 'postgre']
+};
+setLanguages(textMateLanguages.map(language => _objectSpread2(_objectSpread2({}, language), {}, {
+  configuration: loader$2[language.id] != null ? "./".concat(language.id, "-configuration.json") : undefined
+})));
+
+for (const [languageId, aliases] of Object.entries(customAliases)) {
+  monaco.languages.register({
+    id: languageId,
+    aliases
+  });
+}
+
+for (const textMateLanguage of textMateLanguages) {
+  const configurationLoader = loader$2[textMateLanguage.id];
+
+  if (configurationLoader != null) {
+    setLanguageConfiguration("/".concat(textMateLanguage.id, "-configuration.json"), async () => JSON.stringify(addCustomFoldingMarkers(await configurationLoader())));
+  }
+}
+
+function getMonacoLanguage(languageOrModeId) {
+  const languageService = StandaloneServices.get(ILanguageService);
+  const modeId = languageService.getLanguageIdByLanguageName(languageOrModeId.toLowerCase());
+
+  if (modeId != null) {
+    return modeId;
+  }
+
+  if (languageService.isRegisteredLanguageId(languageOrModeId)) {
+    return languageOrModeId;
+  }
+
+  if (languageService.isRegisteredLanguageId(languageOrModeId.toLowerCase())) {
+    return languageOrModeId.toLowerCase();
+  }
+
+  return 'plaintext';
+}
+
+async function loadLanguage(languageId) {
+  StandaloneServices.get(ILanguageService).createById(languageId);
+}
+
+var defaultThemes = [
+  {
+    "id": "Default Dark+",
+    "label": "Dark+ (default dark)",
+    "uiTheme": "vs-dark",
+    "path": "./themes/dark_plus.json",
+    "extension": "theme-defaults"
+  },
+  {
+    "id": "Default Light+",
+    "label": "Light+ (default light)",
+    "uiTheme": "vs",
+    "path": "./themes/light_plus.json",
+    "extension": "theme-defaults"
+  },
+  {
+    "id": "Visual Studio Dark",
+    "label": "Dark (Visual Studio)",
+    "uiTheme": "vs-dark",
+    "path": "./themes/dark_vs.json",
+    "extension": "theme-defaults"
+  },
+  {
+    "id": "Visual Studio Light",
+    "label": "Light (Visual Studio)",
+    "uiTheme": "vs",
+    "path": "./themes/light_vs.json",
+    "extension": "theme-defaults"
+  },
+  {
+    "id": "Default High Contrast",
+    "label": "Dark High Contrast",
+    "uiTheme": "hc-black",
+    "path": "./themes/hc_black.json",
+    "extension": "theme-defaults"
+  },
+  {
+    "id": "Default High Contrast Light",
+    "label": "Light High Contrast",
+    "uiTheme": "hc-light",
+    "path": "./themes/hc_light.json",
+    "extension": "theme-defaults"
+  }
+];
+
+// Generated file, do not modify
+
+/* eslint-disable */
+const loader = {
+  'theme-defaults:/themes/dark_plus.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/dark_plus.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~dark_plus.js').then(module => module)).default,
+  'theme-defaults:/themes/light_plus.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/light_plus.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~light_plus.js').then(module => module)).default,
+  'theme-defaults:/themes/dark_vs.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/dark_vs.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~dark_vs.js').then(module => module)).default,
+  'theme-defaults:/themes/light_vs.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/light_vs.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~light_vs.js').then(module => module)).default,
+  'theme-defaults:/themes/hc_black.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/hc_black.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~hc_black.js').then(module => module)).default,
+  'theme-defaults:/themes/hc_light.json': async () => (await import(
+  /* webpackChunkName: "theme-theme-defaults:/themes/hc_light.json" */
+
+  /* webpackMode: "eager" */
+  './theme-defaults~hc_light.js').then(module => module)).default
+};
+
+registerColor('statusBar.foreground', {
+  dark: '#ffffff',
+  light: '#20252a',
+  hcDark: '#ffffff',
+  hcLight: '#20252a'
+}, 'Status bar foreground color.');
+registerColor('statusBar.background', {
+  dark: '#252e38',
+  light: '#ffffff',
+  hcDark: null,
+  hcLight: null
+}, 'Status bar background color.');
+registerColor('statusBar.border', {
+  dark: '#41454a',
+  light: '#dadada',
+  hcDark: '#41454a',
+  hcLight: '#dadada'
+}, 'Status bar border color.');
+setDefaultThemes(defaultThemes.map(themeExtensionPoint => _objectSpread2(_objectSpread2({}, themeExtensionPoint), {}, {
+  load: async () => JSON.stringify(await loader["".concat(themeExtensionPoint.extension, ":").concat(themeExtensionPoint.path.slice(1))]())
+})), async themeExtensionPoint => themeExtensionPoint.load());
+let themes = [];
+
+function updateThemes() {
+  setThemes(themes, async themeExtensionPoint => themeExtensionPoint.load());
+}
+
+updateThemes();
+
+function defineVSCodeTheme(id, load) {
+  const theme = {
+    id,
+    path: "/".concat(id, ".json"),
+    load,
+    _watch: false
+  };
+  themes = [...themes, theme];
+  updateThemes();
+  return {
+    dispose() {
+      themes = themes.filter(_theme => _theme !== theme);
+      updateThemes();
+    }
+
+  };
+}
+
+const fixedPositions = [0, 6, 7, 11];
+const lastFixedPosition = fixedPositions[fixedPositions.length - 1];
+
+function getIndentWidth(editor) {
+  return editor.getModel().getOptions().tabSize;
+}
+
+function findFirstNonSpacePosition(line) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] !== ' ') {
+      return i;
+    }
+  }
+
+  return line.length;
+}
+
+function indentLine(editor, lineNumber) {
+  if (editor.getModel() == null) {
+    return;
+  }
+
+  const line = editor.getModel().getLineContent(lineNumber);
+  const nonSpacePosition = findFirstNonSpacePosition(line);
+  const nextFixedPosition = fixedPositions.find(p => p > nonSpacePosition);
+  let expectedIndent = nextFixedPosition;
+
+  if (expectedIndent == null) {
+    const expectedIndentCount = Math.floor((nonSpacePosition - lastFixedPosition) / getIndentWidth(editor)) + 1;
+    expectedIndent = lastFixedPosition + getIndentWidth(editor) * expectedIndentCount;
+  }
+
+  const toInsert = expectedIndent - nonSpacePosition;
+  const range = new monaco.Range(lineNumber, 1, lineNumber, 1);
+  editor.executeEdits('indent', [{
+    range,
+    text: ' '.repeat(toInsert),
+    forceMoveMarkers: true
+  }]);
+}
+
+function unindentLine(editor, lineNumber) {
+  var _fixedPositions$slice;
+
+  if (editor.getModel() == null) {
+    return;
+  }
+
+  const line = editor.getModel().getLineContent(lineNumber);
+  const nonSpacePosition = findFirstNonSpacePosition(line);
+  const fixedIndentWidth = getIndentWidth(editor);
+  const prevFixedPosition = (_fixedPositions$slice = fixedPositions.slice().reverse().find(p => p < nonSpacePosition)) !== null && _fixedPositions$slice !== void 0 ? _fixedPositions$slice : 0;
+  let expectedIndent = prevFixedPosition;
+
+  if (prevFixedPosition === lastFixedPosition) {
+    // Instead of going back to the last fixed position, go to the nearest (prevFixedPosition + tabSize * N) position
+    const expectedIndentCount = Math.floor((nonSpacePosition - lastFixedPosition - 1) / fixedIndentWidth);
+    expectedIndent = lastFixedPosition + fixedIndentWidth * expectedIndentCount;
+  }
+
+  const toRemove = nonSpacePosition - expectedIndent;
+  const range = new monaco.Range(lineNumber, 1, lineNumber, 1 + toRemove);
+  editor.executeEdits('indent', [{
+    range,
+    text: '',
+    forceMoveMarkers: true
+  }]);
+}
+
+function setup$2(editor) {
+  editor.addCommand(monaco.KeyCode.Tab, () => {
+    var _editor$getSelections;
+
+    (_editor$getSelections = editor.getSelections()) === null || _editor$getSelections === void 0 ? void 0 : _editor$getSelections.forEach(selection => {
+      for (let lineNumber = selection.startLineNumber; lineNumber <= selection.endLineNumber; lineNumber++) {
+        indentLine(editor, lineNumber);
+      }
+    });
+  }, 'editorLangId == COBOL && !inSnippetMode');
+  editor.addCommand(monaco.KeyMod.Shift | monaco.KeyCode.Tab, () => {
+    var _editor$getSelections2;
+
+    (_editor$getSelections2 = editor.getSelections()) === null || _editor$getSelections2 === void 0 ? void 0 : _editor$getSelections2.forEach(selection => {
+      for (let lineNumber = selection.startLineNumber; lineNumber <= selection.endLineNumber; lineNumber++) {
+        unindentLine(editor, lineNumber);
+      }
+    });
+  }, 'editorLangId == COBOL && !inSnippetMode');
+}
+
+function setup$1(editor) {
+  editor.addAction({
+    id: 'editor.foldAllAutofoldRegions',
+    label: 'Fold all autofold regions',
+    run: async editor => {
+      const foldingController = FoldingController.get(editor);
+      const foldingModelPromise = foldingController === null || foldingController === void 0 ? void 0 : foldingController.getFoldingModel();
+
+      if (foldingModelPromise != null) {
+        return foldingModelPromise.then(foldingModel => {
+          const editorModel = editor.getModel();
+
+          if (editorModel == null || foldingModel == null) {
+            return;
+          }
+
+          const regExp = /.*autofold.*/;
+          setCollapseStateForMatchingLines(foldingModel, regExp, true);
+        });
+      }
+    }
+  });
+}
+
+function setup(editor) {
+  setup$2(editor);
+  setup$1(editor);
+}
+
+let currentEditor = null;
+
+function openNewCodeEditor(model) {
+  if (currentEditor != null && model === currentEditor.model) {
+    return currentEditor.editor;
+  }
+
+  if (currentEditor != null) {
+    currentEditor.dispose();
+    currentEditor = null;
+  }
+
+  const container = document.createElement('div');
+  container.style.position = 'fixed';
+  container.style.zIndex = '10000';
+  container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+  container.style.top = container.style.bottom = container.style.left = container.style.right = '0';
+  container.style.cursor = 'pointer';
+  const editorElem = document.createElement('div');
+  editorElem.style.position = 'absolute';
+  editorElem.style.top = editorElem.style.bottom = editorElem.style.left = editorElem.style.right = '0';
+  editorElem.style.margin = 'auto';
+  editorElem.style.width = '80%';
+  editorElem.style.height = '80%';
+  container.appendChild(editorElem);
+  document.body.appendChild(container);
+
+  try {
+    const editor = createEditor(editorElem, _objectSpread2({
+      model,
+      readOnly: true,
+      automaticLayout: true
+    }, getConfiguration(model.getLanguageId(), 'editor')));
+    currentEditor = {
+      dispose: () => {
+        editor.dispose();
+        document.body.removeChild(container);
+        currentEditor = null;
+      },
+      model,
+      editor
+    };
+    container.addEventListener('mousedown', event => {
+      var _currentEditor;
+
+      if (event.target !== container) {
+        return;
+      }
+
+      (_currentEditor = currentEditor) === null || _currentEditor === void 0 ? void 0 : _currentEditor.dispose();
+    });
+    return editor;
+  } catch (error) {
+    document.body.removeChild(container);
+    currentEditor = null;
+    throw error;
+  }
+}
+
+class EditorOpenHandlerRegistry {
+  constructor() {
+    _defineProperty(this, "handlers", []);
+
+    _defineProperty(this, "openCodeEditor", async (model, options, sideBySide) => {
+      var _modelEditor$getDomNo;
+
+      let modelEditor;
+
+      for (const handler of this.handlers) {
+        const handlerEditor = await handler(model, options, null, sideBySide);
+
+        if (handlerEditor != null) {
+          modelEditor = handlerEditor;
+          break;
+        }
+      }
+
+      if (modelEditor == null) {
+        modelEditor = openNewCodeEditor(model); // Destroy model ref when we close the editor popup
+
+        const onModelUnmount = () => {
+          model.dispose();
+        };
+
+        const onDidDisposeDisposable = modelEditor.onDidDispose(() => {
+          onModelUnmount();
+        });
+        const onDidChangeModelDisposable = modelEditor.onDidChangeModel(e => {
+          if (e.newModelUrl == null || e.newModelUrl.toString() !== model.uri.toString()) {
+            onModelUnmount();
+            onDidDisposeDisposable.dispose();
+            onDidChangeModelDisposable.dispose();
+          }
+        });
+      }
+
+      modelEditor.focus();
+
+      if (((_modelEditor$getDomNo = modelEditor.getDomNode()) === null || _modelEditor$getDomNo === void 0 ? void 0 : _modelEditor$getDomNo.scrollIntoView) != null) {
+        var _modelEditor$getDomNo2;
+
+        (_modelEditor$getDomNo2 = modelEditor.getDomNode()) === null || _modelEditor$getDomNo2 === void 0 ? void 0 : _modelEditor$getDomNo2.scrollIntoView({
+          block: 'nearest',
+          inline: 'nearest'
+        });
+      }
+
+      return modelEditor;
+    });
+  }
+
+  registerEditorOpenHandler(handler) {
+    this.handlers.push(handler);
+    return {
+      dispose: () => {
+        const index = this.handlers.indexOf(handler);
+
+        if (index >= 0) {
+          this.handlers.splice(index, 1);
+        }
+      }
+    };
+  }
+
+}
+
+const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
+StandaloneServices.initialize(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
+  return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
+})), getMessageServiceOverride(document.body)), getConfigurationServiceOverride()), getKeybindingsServiceOverride()), getTextmateServiceOverride(async () => {
+  const response = await fetch(onigFile);
+  return await response.arrayBuffer();
+})), getThemeServiceOverride()), geTokenClassificationServiceOverride()), getLanguageConfigurationServiceOverride()), getSnippetConfigurationServiceOverride()), getLanguagesServiceOverride()));
+errorHandler.setUnexpectedErrorHandler(error => {
+  console.warn('Unexpected error', error);
+});
+
+function createEditor(domElement, options) {
+  const editor = createConfiguredEditor(domElement, options);
+  setup(editor);
+  return editor;
+}
+
+function registerTextModelContentProvider(scheme, provider) {
+  const textModelService = StandaloneServices.get(ITextModelService);
+  return textModelService.registerTextModelContentProvider(scheme, provider);
+}
+
+function registerEditorOpenHandler(handler) {
+  return editorOpenHandlerRegistry.registerEditorOpenHandler(handler);
+}
+
+function updateKeybindings(bindingsJson) {
+  updateUserKeybindings(bindingsJson);
+}
+
+class PromiseDisposable {
+  constructor(promise) {
+    this.promise = promise;
+  }
+
+  dispose() {
+    this.promise.then(disposable => disposable.dispose(), console.error);
+  }
+
+}
+
+function updateEditorKeybindingsMode(editor) {
+  let keyBindingsMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'classic';
+  let statusBarElement = arguments.length > 2 ? arguments[2] : undefined;
+
+  switch (keyBindingsMode) {
+    case 'vim':
+      {
+        return new PromiseDisposable(import('./vim.js').then(module => module).then(_ref => {
+          let {
+            initVimMode
+          } = _ref;
+          return initVimMode(editor, statusBarElement);
+        }));
+      }
+
+    case 'emacs':
+      {
+        return new PromiseDisposable(import('./index2.js').then(module => module).then(function (n) { return n.i; }).then(_ref2 => {
+          let {
+            default: EmacsExtension
+          } = _ref2;
+          const emacsExtension = new EmacsExtension(editor);
+          emacsExtension.start();
+          return emacsExtension;
+        }));
+      }
+
+    default:
+      {
+        return {
+          dispose: () => {}
+        };
+      }
+  }
+}
+
+function isPasteAction(handlerId, payload) {
+  return handlerId === 'paste';
+}
+
+function lockCodeWithoutDecoration(editor, decorations, allowChangeFromSources, errorMessage) {
+  function displayLockedCodeError(position) {
+    if (errorMessage == null) {
+      return;
+    }
+
+    const messageContribution = editor.getContribution('editor.contrib.messageController') // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;
+    messageContribution.showMessage(errorMessage, position);
+  }
+
+  function canEditRange(range) {
+    const model = editor.getModel();
+
+    if (model != null) {
+      const editableRanges = decorations.map(decoration => model.getDecorationRange(decoration));
+      return editableRanges.some(editableRange => {
+        var _editableRange$contai;
+
+        return (_editableRange$contai = editableRange === null || editableRange === void 0 ? void 0 : editableRange.containsRange(range)) !== null && _editableRange$contai !== void 0 ? _editableRange$contai : false;
+      });
+    }
+
+    return false;
+  }
+
+  const originalExecuteCommands = editor.executeCommands;
+
+  editor.executeCommands = function (name, commands) {
+    for (const command of commands) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const range = command === null || command === void 0 ? void 0 : command._range;
+
+      if (range != null && !canEditRange(range)) {
+        displayLockedCodeError(range.getEndPosition());
+        return;
+      }
+    }
+
+    return originalExecuteCommands.call(editor, name, commands);
+  };
+
+  const originalTrigger = editor.trigger;
+
+  editor.trigger = function (source, handlerId, payload) {
+    var _editor$getModel;
+
+    // Try to transform whole file pasting into a paste in the editable area only
+    const lastEditableRange = decorations.length > 0 ? (_editor$getModel = editor.getModel()) === null || _editor$getModel === void 0 ? void 0 : _editor$getModel.getDecorationRange(decorations[decorations.length - 1]) : null;
+
+    if (isPasteAction(handlerId) && lastEditableRange != null) {
+      const selections = editor.getSelections();
+      const model = editor.getModel();
+
+      if (selections != null && selections.length === 1) {
+        const selection = selections[0];
+        const fullModelRange = model.getFullModelRange();
+        const wholeFileSelected = fullModelRange.equalsRange(selection);
+
+        if (wholeFileSelected) {
+          const currentEditorValue = editor.getValue();
+          const before = model.getOffsetAt(lastEditableRange.getStartPosition());
+          const after = currentEditorValue.length - model.getOffsetAt(lastEditableRange.getEndPosition());
+
+          if (currentEditorValue.slice(0, before) === payload.text.slice(0, before) && currentEditorValue.slice(currentEditorValue.length - after) === payload.text.slice(payload.text.length - after)) {
+            editor.setSelection(lastEditableRange);
+
+            const newPayload = _objectSpread2(_objectSpread2({}, payload), {}, {
+              text: payload.text.slice(before, payload.text.length - after)
+            });
+
+            payload = newPayload;
+          }
+        }
+      }
+    }
+
+    if (['type', 'paste', 'cut'].includes(handlerId)) {
+      const selections = editor.getSelections();
+
+      if (selections != null && selections.some(range => !canEditRange(range))) {
+        displayLockedCodeError(editor.getPosition());
+        return;
+      }
+    }
+
+    return originalTrigger.call(editor, source, handlerId, payload);
+  };
+
+  let currentEditSource;
+  const originalExecuteEdit = editor.executeEdits;
+
+  editor.executeEdits = (source, edits, endCursorState) => {
+    currentEditSource = source;
+
+    try {
+      return originalExecuteEdit.call(editor, source, edits, endCursorState);
+    } finally {
+      currentEditSource = null;
+    }
+  };
+
+  let restoreModelApplyEdit = () => {};
+
+  function lockModel() {
+    restoreModelApplyEdit();
+    const model = editor.getModel();
+
+    if (model == null) {
+      return;
+    }
+
+    const originalApplyEdit = model.applyEdits;
+
+    model.applyEdits = (operations, computeUndoEdits) => {
+      if (currentEditSource != null && allowChangeFromSources.includes(currentEditSource)) {
+        return originalApplyEdit.call(model, operations, computeUndoEdits);
+      }
+
+      const filteredOperations = operations.filter(operation => canEditRange(operation.range));
+
+      if (filteredOperations.length === 0 && operations.length > 0) {
+        const firstRange = operations[0].range;
+        displayLockedCodeError(new monaco.Position(firstRange.startLineNumber, firstRange.startColumn));
+      }
+
+      return originalApplyEdit.call(model, filteredOperations, computeUndoEdits);
+    };
+
+    restoreModelApplyEdit = () => {
+      model.applyEdits = originalApplyEdit;
+    };
+  }
+
+  const editorChangeModelDisposable = editor.onDidChangeModel(lockModel);
+  lockModel(); // Handle selection of the last line of an editable range
+
+  const selectionDisposable = editor.onDidChangeCursorSelection(e => {
+    if (canEditRange(e.selection)) {
+      return;
+    }
+
+    const model = editor.getModel();
+
+    if (model == null) {
+      return;
+    }
+
+    const shiftedRange = monaco.Range.fromPositions(model.getPositionAt(model.getOffsetAt(e.selection.getStartPosition()) - 1), model.getPositionAt(model.getOffsetAt(e.selection.getEndPosition()) - 1));
+
+    if (canEditRange(shiftedRange)) {
+      editor.setSelection(shiftedRange);
+    }
+  });
+  return () => {
+    selectionDisposable.dispose();
+    restoreModelApplyEdit();
+    editorChangeModelDisposable.dispose();
+    editor.executeEdits = originalExecuteEdit;
+    editor.executeCommands = originalExecuteCommands;
+    editor.trigger = originalTrigger;
+  };
+}
+function hideCodeWithoutDecoration(editor, decorations) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let otherHiddenAreas = editor._getViewModel()._lines.getHiddenAreas();
+
+  function getHiddenAreas() {
+    const model = editor.getModel();
+    const ranges = decorations.map(decoration => model.getDecorationRange(decoration)).sort((a, b) => a.startLineNumber - b.startLineNumber) // merge ranges
+    .reduce((acc, range) => {
+      if (acc.length === 0) {
+        return [range];
+      }
+
+      const lastRange = acc[acc.length - 1];
+
+      if (range.getStartPosition().isBeforeOrEqual(lastRange.getEndPosition())) {
+        return [...acc.slice(0, -1), monaco.Range.fromPositions(lastRange.getStartPosition(), range.getEndPosition())];
+      } else {
+        return [...acc, range];
+      }
+    }, []);
+    let hiddenAreas = [...otherHiddenAreas];
+    let position = new monaco.Position(1, 1);
+
+    for (const range of ranges) {
+      const startPosition = model.modifyPosition(range.getStartPosition(), -1);
+      const endPosition = model.modifyPosition(range.getEndPosition(), 1);
+      hiddenAreas = [...hiddenAreas, monaco.Range.fromPositions(position, startPosition)];
+      position = endPosition;
+    }
+
+    hiddenAreas = [...hiddenAreas, monaco.Range.fromPositions(position, model.getFullModelRange().getEndPosition())];
+    return hiddenAreas;
+  }
+
+  const originalSetHiddenAreas = editor.setHiddenAreas.bind(editor);
+
+  function updateHiddenAreas() {
+    originalSetHiddenAreas(getHiddenAreas());
+  } // Hack to make it work with the folding service calling setHiddenAreas with its own areas
+
+
+  editor.setHiddenAreas = ranges => {
+    otherHiddenAreas = ranges;
+    updateHiddenAreas();
+  };
+
+  updateHiddenAreas();
+  return () => {
+    editor.setHiddenAreas = originalSetHiddenAreas;
+    editor.setHiddenAreas(otherHiddenAreas);
+  };
+}
+
+export { createEditor, defineVSCodeTheme, getMonacoLanguage, hideCodeWithoutDecoration, loadLanguage, lockCodeWithoutDecoration, registerEditorOpenHandler, registerTextModelContentProvider, updateEditorKeybindingsMode, updateKeybindings };