@coze-editor/preset-code-languages 0.1.0-alpha.9a9cc7 → 0.1.0-alpha.e5f73a

package/dist/index.js

@@ -39,6 +39,9 @@ var import_core = require("@coze-editor/core");
 
 // src/languages.ts
 var import_language = require("@codemirror/language");
+function legacy(parser) {
+  return new import_language.LanguageSupport(import_language.StreamLanguage.define(parser));
+}
 var supportedLanguages = [
   import_language.LanguageDescription.of({
     name: "VUE",
@@ -51,7 +54,7 @@ var supportedLanguages = [
     name: "TS",
     extensions: ["ts"],
     async load() {
-      return import("@codemirror/lang-javascript").then(
+      return import("@coze-editor/lang-javascript").then(
         (module2) => module2.javascript({ typescript: true })
       );
     }
@@ -60,7 +63,7 @@ var supportedLanguages = [
     name: "JS",
     extensions: ["js", "mjs", "cjs"],
     async load() {
-      return import("@codemirror/lang-javascript").then(
+      return import("@coze-editor/lang-javascript").then(
         (module2) => module2.javascript()
       );
     }
@@ -69,7 +72,7 @@ var supportedLanguages = [
     name: "TSX",
     extensions: ["tsx"],
     async load() {
-      return import("@codemirror/lang-javascript").then(
+      return import("@coze-editor/lang-javascript").then(
         (module2) => module2.javascript({
           jsx: true,
           typescript: true
@@ -81,14 +84,14 @@ var supportedLanguages = [
     name: "JSX",
     extensions: ["jsx"],
     async load() {
-      return import("@codemirror/lang-javascript").then(
+      return import("@coze-editor/lang-javascript").then(
         (module2) => module2.javascript({ jsx: true })
       );
     }
   }),
   import_language.LanguageDescription.of({
     name: "HTML",
-    extensions: ["html", "svg"],
+    extensions: ["html", "htm", "handlebars", "hbs"],
     async load() {
       return import("@codemirror/lang-html").then((module2) => module2.html());
     }
@@ -118,6 +121,13 @@ var supportedLanguages = [
       );
     }
   }),
+  import_language.LanguageDescription.of({
+    name: "LESS",
+    extensions: ["less"],
+    load() {
+      return import("@codemirror/lang-less").then((m) => m.less());
+    }
+  }),
   import_language.LanguageDescription.of({
     name: "JSON",
     extensions: ["json"],
@@ -127,7 +137,7 @@ var supportedLanguages = [
   }),
   import_language.LanguageDescription.of({
     name: "Markdown",
-    extensions: ["md"],
+    extensions: ["md", "markdown", "mkd"],
     async load() {
       return import("@codemirror/lang-markdown").then(
         (module2) => module2.markdown()
@@ -155,6 +165,13 @@ var supportedLanguages = [
       return import("@codemirror/lang-cpp").then((module2) => module2.cpp());
     }
   }),
+  import_language.LanguageDescription.of({
+    name: "C",
+    extensions: ["c"],
+    async load() {
+      return import("@codemirror/lang-cpp").then((module2) => module2.cpp());
+    }
+  }),
   import_language.LanguageDescription.of({
     name: "Shell",
     extensions: ["sh"],
@@ -170,6 +187,1040 @@ var supportedLanguages = [
     async load() {
       return import("@codemirror/lang-sql").then((module2) => module2.sql());
     }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Go",
+    extensions: ["go"],
+    async load() {
+      return import("@codemirror/lang-go").then((module2) => module2.go());
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Rust",
+    extensions: ["rs"],
+    async load() {
+      return import("@codemirror/lang-rust").then((module2) => module2.rust());
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "PHP",
+    extensions: ["php", "php3", "php4", "php5", "php7", "phtml"],
+    async load() {
+      return import("@codemirror/lang-php").then((module2) => module2.php());
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Java",
+    extensions: ["java"],
+    async load() {
+      return import("@codemirror/lang-java").then((module2) => module2.java());
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "YAML",
+    extensions: ["yml", "yaml"],
+    async load() {
+      return import("@codemirror/lang-yaml").then((module2) => module2.yaml());
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "XML",
+    extensions: ["xml", "xsl", "xsd", "svg"],
+    async load() {
+      return import("@codemirror/lang-xml").then((module2) => module2.xml());
+    }
+  }),
+  // legacy
+  import_language.LanguageDescription.of({
+    name: "APL",
+    extensions: ["dyalog", "apl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/apl").then(
+        (m) => legacy(m.apl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "PGP",
+    alias: ["asciiarmor"],
+    extensions: ["asc", "pgp", "sig"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/asciiarmor").then(
+        (m) => legacy(m.asciiArmor)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "ASN.1",
+    extensions: ["asn", "asn1"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/asn1").then(
+        (m) => legacy(m.asn1({}))
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Asterisk",
+    filename: /^extensions\.conf$/i,
+    load() {
+      return import("@codemirror/legacy-modes/mode/asterisk").then(
+        (m) => legacy(m.asterisk)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Brainfuck",
+    extensions: ["b", "bf"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/brainfuck").then(
+        (m) => legacy(m.brainfuck)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Cobol",
+    extensions: ["cob", "cpy"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/cobol").then(
+        (m) => legacy(m.cobol)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "C#",
+    alias: ["csharp", "cs"],
+    extensions: ["cs"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.csharp)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Clojure",
+    extensions: ["clj", "cljc", "cljx"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clojure").then(
+        (m) => legacy(m.clojure)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "ClojureScript",
+    extensions: ["cljs"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clojure").then(
+        (m) => legacy(m.clojure)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Closure Stylesheets (GSS)",
+    extensions: ["gss"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/css").then(
+        (m) => legacy(m.gss)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "CMake",
+    extensions: ["cmake", "cmake.in"],
+    filename: /^CMakeLists\.txt$/,
+    load() {
+      return import("@codemirror/legacy-modes/mode/cmake").then(
+        (m) => legacy(m.cmake)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "CoffeeScript",
+    alias: ["coffee", "coffee-script"],
+    extensions: ["coffee"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/coffeescript").then(
+        (m) => legacy(m.coffeeScript)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Common Lisp",
+    alias: ["lisp"],
+    extensions: ["cl", "lisp", "el"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/commonlisp").then(
+        (m) => legacy(m.commonLisp)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Cypher",
+    extensions: ["cyp", "cypher"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/cypher").then(
+        (m) => legacy(m.cypher)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Cython",
+    extensions: ["pyx", "pxd", "pxi"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/python").then(
+        (m) => legacy(m.cython)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Crystal",
+    extensions: ["cr"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/crystal").then(
+        (m) => legacy(m.crystal)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "D",
+    extensions: ["d"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/d").then((m) => legacy(m.d));
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Dart",
+    extensions: ["dart"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.dart)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "diff",
+    extensions: ["diff", "patch"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/diff").then(
+        (m) => legacy(m.diff)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Dockerfile",
+    filename: /^Dockerfile$/,
+    load() {
+      return import("@codemirror/legacy-modes/mode/dockerfile").then(
+        (m) => legacy(m.dockerFile)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "DTD",
+    extensions: ["dtd"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/dtd").then(
+        (m) => legacy(m.dtd)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Dylan",
+    extensions: ["dylan", "dyl", "intr"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/dylan").then(
+        (m) => legacy(m.dylan)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "EBNF",
+    load() {
+      return import("@codemirror/legacy-modes/mode/ebnf").then(
+        (m) => legacy(m.ebnf)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "ECL",
+    extensions: ["ecl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/ecl").then(
+        (m) => legacy(m.ecl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "edn",
+    extensions: ["edn"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clojure").then(
+        (m) => legacy(m.clojure)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Eiffel",
+    extensions: ["e"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/eiffel").then(
+        (m) => legacy(m.eiffel)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Elm",
+    extensions: ["elm"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/elm").then(
+        (m) => legacy(m.elm)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Erlang",
+    extensions: ["erl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/erlang").then(
+        (m) => legacy(m.erlang)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Esper",
+    load() {
+      return import("@codemirror/legacy-modes/mode/sql").then(
+        (m) => legacy(m.esper)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Factor",
+    extensions: ["factor"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/factor").then(
+        (m) => legacy(m.factor)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "FCL",
+    load() {
+      return import("@codemirror/legacy-modes/mode/fcl").then(
+        (m) => legacy(m.fcl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Forth",
+    extensions: ["forth", "fth", "4th"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/forth").then(
+        (m) => legacy(m.forth)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Fortran",
+    extensions: ["f", "for", "f77", "f90", "f95"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/fortran").then(
+        (m) => legacy(m.fortran)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "F#",
+    alias: ["fsharp"],
+    extensions: ["fs"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mllike").then(
+        (m) => legacy(m.fSharp)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Gas",
+    extensions: ["s"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/gas").then(
+        (m) => legacy(m.gas)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Gherkin",
+    extensions: ["feature"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/gherkin").then(
+        (m) => legacy(m.gherkin)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Groovy",
+    extensions: ["groovy", "gradle"],
+    filename: /^Jenkinsfile$/,
+    load() {
+      return import("@codemirror/legacy-modes/mode/groovy").then(
+        (m) => legacy(m.groovy)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Haskell",
+    extensions: ["hs"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/haskell").then(
+        (m) => legacy(m.haskell)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Haxe",
+    extensions: ["hx"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/haxe").then(
+        (m) => legacy(m.haxe)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "HXML",
+    extensions: ["hxml"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/haxe").then(
+        (m) => legacy(m.hxml)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "HTTP",
+    load() {
+      return import("@codemirror/legacy-modes/mode/http").then(
+        (m) => legacy(m.http)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "IDL",
+    extensions: ["pro"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/idl").then(
+        (m) => legacy(m.idl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "JSON-LD",
+    alias: ["jsonld"],
+    extensions: ["jsonld"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/javascript").then(
+        (m) => legacy(m.jsonld)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Julia",
+    extensions: ["jl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/julia").then(
+        (m) => legacy(m.julia)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Kotlin",
+    extensions: ["kt", "kts"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.kotlin)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "LiveScript",
+    alias: ["ls"],
+    extensions: ["ls"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/livescript").then(
+        (m) => legacy(m.liveScript)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Lua",
+    extensions: ["lua"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/lua").then(
+        (m) => legacy(m.lua)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "mIRC",
+    extensions: ["mrc"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mirc").then(
+        (m) => legacy(m.mirc)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Mathematica",
+    extensions: ["m", "nb", "wl", "wls"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mathematica").then(
+        (m) => legacy(m.mathematica)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Modelica",
+    extensions: ["mo"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/modelica").then(
+        (m) => legacy(m.modelica)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "MUMPS",
+    extensions: ["mps"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mumps").then(
+        (m) => legacy(m.mumps)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Mbox",
+    extensions: ["mbox"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mbox").then(
+        (m) => legacy(m.mbox)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Nginx",
+    filename: /nginx.*\.conf$/i,
+    load() {
+      return import("@codemirror/legacy-modes/mode/nginx").then(
+        (m) => legacy(m.nginx)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "NSIS",
+    extensions: ["nsh", "nsi"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/nsis").then(
+        (m) => legacy(m.nsis)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "NTriples",
+    extensions: ["nt", "nq"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/ntriples").then(
+        (m) => legacy(m.ntriples)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Objective-C",
+    alias: ["objective-c", "objc"],
+    extensions: ["m"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.objectiveC)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Objective-C++",
+    alias: ["objective-c++", "objc++"],
+    extensions: ["mm"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.objectiveCpp)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "OCaml",
+    extensions: ["ml", "mli", "mll", "mly"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mllike").then(
+        (m) => legacy(m.oCaml)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Octave",
+    extensions: ["m"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/octave").then(
+        (m) => legacy(m.octave)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Oz",
+    extensions: ["oz"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/oz").then((m) => legacy(m.oz));
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Pascal",
+    extensions: ["p", "pas"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/pascal").then(
+        (m) => legacy(m.pascal)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Perl",
+    extensions: ["pl", "pm"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/perl").then(
+        (m) => legacy(m.perl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Pig",
+    extensions: ["pig"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/pig").then(
+        (m) => legacy(m.pig)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "PowerShell",
+    extensions: ["ps1", "psd1", "psm1"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/powershell").then(
+        (m) => legacy(m.powerShell)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Properties files",
+    alias: ["ini", "properties"],
+    extensions: ["properties", "ini", "in"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/properties").then(
+        (m) => legacy(m.properties)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "ProtoBuf",
+    extensions: ["proto"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/protobuf").then(
+        (m) => legacy(m.protobuf)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Pug",
+    alias: ["jade"],
+    extensions: ["pug", "jade"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/pug").then(
+        (m) => legacy(m.pug)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Puppet",
+    extensions: ["pp"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/puppet").then(
+        (m) => legacy(m.puppet)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Q",
+    extensions: ["q"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/q").then((m) => legacy(m.q));
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "R",
+    alias: ["rscript"],
+    extensions: ["r", "R"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/r").then((m) => legacy(m.r));
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "RPM Changes",
+    load() {
+      return import("@codemirror/legacy-modes/mode/rpm").then(
+        (m) => legacy(m.rpmChanges)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "RPM Spec",
+    extensions: ["spec"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/rpm").then(
+        (m) => legacy(m.rpmSpec)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Ruby",
+    alias: ["jruby", "macruby", "rake", "rb", "rbx"],
+    extensions: ["rb"],
+    filename: /^(Gemfile|Rakefile)$/,
+    load() {
+      return import("@codemirror/legacy-modes/mode/ruby").then(
+        (m) => legacy(m.ruby)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "SAS",
+    extensions: ["sas"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/sas").then(
+        (m) => legacy(m.sas)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Scala",
+    extensions: ["scala"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.scala)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Scheme",
+    extensions: ["scm", "ss"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/scheme").then(
+        (m) => legacy(m.scheme)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Shell",
+    alias: ["bash", "sh", "zsh"],
+    extensions: ["sh", "ksh", "bash"],
+    filename: /^PKGBUILD$/,
+    load() {
+      return import("@codemirror/legacy-modes/mode/shell").then(
+        (m) => legacy(m.shell)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Sieve",
+    extensions: ["siv", "sieve"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/sieve").then(
+        (m) => legacy(m.sieve)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Smalltalk",
+    extensions: ["st"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/smalltalk").then(
+        (m) => legacy(m.smalltalk)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Solr",
+    load() {
+      return import("@codemirror/legacy-modes/mode/solr").then(
+        (m) => legacy(m.solr)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "SML",
+    extensions: ["sml", "sig", "fun", "smackspec"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mllike").then(
+        (m) => legacy(m.sml)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "SPARQL",
+    alias: ["sparul"],
+    extensions: ["rq", "sparql"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/sparql").then(
+        (m) => legacy(m.sparql)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Spreadsheet",
+    alias: ["excel", "formula"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/spreadsheet").then(
+        (m) => legacy(m.spreadsheet)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Squirrel",
+    extensions: ["nut"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/clike").then(
+        (m) => legacy(m.squirrel)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Stylus",
+    extensions: ["styl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/stylus").then(
+        (m) => legacy(m.stylus)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Swift",
+    extensions: ["swift"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/swift").then(
+        (m) => legacy(m.swift)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "sTeX",
+    load() {
+      return import("@codemirror/legacy-modes/mode/stex").then(
+        (m) => legacy(m.stex)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "LaTeX",
+    alias: ["tex"],
+    extensions: ["text", "ltx", "tex"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/stex").then(
+        (m) => legacy(m.stex)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "SystemVerilog",
+    extensions: ["v", "sv", "svh"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/verilog").then(
+        (m) => legacy(m.verilog)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Tcl",
+    extensions: ["tcl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/tcl").then(
+        (m) => legacy(m.tcl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Textile",
+    extensions: ["textile"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/textile").then(
+        (m) => legacy(m.textile)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "TiddlyWiki",
+    load() {
+      return import("@codemirror/legacy-modes/mode/tiddlywiki").then(
+        (m) => legacy(m.tiddlyWiki)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Tiki wiki",
+    load() {
+      return import("@codemirror/legacy-modes/mode/tiki").then(
+        (m) => legacy(m.tiki)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "TOML",
+    extensions: ["toml"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/toml").then(
+        (m) => legacy(m.toml)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Troff",
+    extensions: ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/troff").then(
+        (m) => legacy(m.troff)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "TTCN",
+    extensions: ["ttcn", "ttcn3", "ttcnpp"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/ttcn").then(
+        (m) => legacy(m.ttcn)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "TTCN_CFG",
+    extensions: ["cfg"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/ttcn-cfg").then(
+        (m) => legacy(m.ttcnCfg)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Turtle",
+    extensions: ["ttl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/turtle").then(
+        (m) => legacy(m.turtle)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Web IDL",
+    extensions: ["webidl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/webidl").then(
+        (m) => legacy(m.webIDL)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "VB.NET",
+    extensions: ["vb"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/vb").then((m) => legacy(m.vb));
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "VBScript",
+    extensions: ["vbs"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/vbscript").then(
+        (m) => legacy(m.vbScript)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Velocity",
+    extensions: ["vtl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/velocity").then(
+        (m) => legacy(m.velocity)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Verilog",
+    extensions: ["v"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/verilog").then(
+        (m) => legacy(m.verilog)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "VHDL",
+    extensions: ["vhd", "vhdl"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/vhdl").then(
+        (m) => legacy(m.vhdl)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "XQuery",
+    extensions: ["xy", "xquery", "xq", "xqm", "xqy"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/xquery").then(
+        (m) => legacy(m.xQuery)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Yacas",
+    extensions: ["ys"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/yacas").then(
+        (m) => legacy(m.yacas)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "Z80",
+    extensions: ["z80"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/z80").then(
+        (m) => legacy(m.z80)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "MscGen",
+    extensions: ["mscgen", "mscin", "msc"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mscgen").then(
+        (m) => legacy(m.mscgen)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "X\xF9",
+    extensions: ["xu"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mscgen").then(
+        (m) => legacy(m.xu)
+      );
+    }
+  }),
+  import_language.LanguageDescription.of({
+    name: "MsGenny",
+    extensions: ["msgenny"],
+    load() {
+      return import("@codemirror/legacy-modes/mode/mscgen").then(
+        (m) => legacy(m.msgenny)
+      );
+    }
   })
 ];
 var languageCache = /* @__PURE__ */ new Map();