'use strict';
var vscodeOniguruma = require('vscode-oniguruma');
var vscodeTextmate = require('vscode-textmate');
const themes = [
"css-variables",
"dark-plus",
"dracula-soft",
"dracula",
"github-dark-dimmed",
"github-dark",
"github-light",
"hc_light",
"light-plus",
"material-theme-darker",
"material-theme-lighter",
"material-theme-ocean",
"material-theme-palenight",
"material-theme",
"min-dark",
"min-light",
"monokai",
"nord",
"one-dark-pro",
"poimandres",
"rose-pine-dawn",
"rose-pine-moon",
"rose-pine",
"slack-dark",
"slack-ochin",
"solarized-dark",
"solarized-light",
"vitesse-dark",
"vitesse-light"
];
const languages = [
{
id: "abap",
scopeName: "source.abap",
path: "abap.tmLanguage.json",
displayName: "ABAP",
samplePath: "abap.sample"
},
{
id: "actionscript-3",
scopeName: "source.actionscript.3",
path: "actionscript-3.tmLanguage.json",
displayName: "ActionScript",
samplePath: "actionscript-3.sample"
},
{
id: "ada",
scopeName: "source.ada",
path: "ada.tmLanguage.json",
displayName: "Ada",
samplePath: "ada.sample"
},
{
id: "apache",
scopeName: "source.apacheconf",
path: "apache.tmLanguage.json",
displayName: "Apache Conf"
},
{
id: "apex",
scopeName: "source.apex",
path: "apex.tmLanguage.json",
displayName: "Apex",
samplePath: "apex.sample"
},
{
id: "apl",
scopeName: "source.apl",
path: "apl.tmLanguage.json",
displayName: "APL",
embeddedLangs: ["html", "xml", "css", "javascript", "json"]
},
{
id: "applescript",
scopeName: "source.applescript",
path: "applescript.tmLanguage.json",
displayName: "AppleScript",
samplePath: "applescript.sample"
},
{
id: "ara",
scopeName: "source.ara",
path: "ara.tmLanguage.json",
displayName: "Ara",
samplePath: "ara.sample"
},
{
id: "asm",
scopeName: "source.asm.x86_64",
path: "asm.tmLanguage.json",
displayName: "Assembly",
samplePath: "asm.sample"
},
{
id: "astro",
scopeName: "source.astro",
path: "astro.tmLanguage.json",
displayName: "Astro",
samplePath: "astro.sample",
embeddedLangs: ["json", "javascript", "typescript", "stylus", "sass", "css", "scss", "less", "postcss", "tsx"]
},
{
id: "awk",
scopeName: "source.awk",
path: "awk.tmLanguage.json",
displayName: "AWK",
samplePath: "awk.sample"
},
{
id: "ballerina",
scopeName: "source.ballerina",
path: "ballerina.tmLanguage.json",
displayName: "Ballerina",
samplePath: "ballerina.sample"
},
{
id: "bat",
scopeName: "source.batchfile",
path: "bat.tmLanguage.json",
displayName: "Batch",
samplePath: "bat.sample",
aliases: ["batch"]
},
{
id: "beancount",
scopeName: "text.beancount",
path: "beancount.tmLanguage.json",
displayName: "Beancount",
samplePath: "beancount.sample"
},
{
id: "berry",
scopeName: "source.berry",
path: "berry.tmLanguage.json",
displayName: "Berry",
samplePath: "berry.sample",
aliases: ["be"]
},
{
id: "bibtex",
scopeName: "text.bibtex",
path: "bibtex.tmLanguage.json",
displayName: "BibTeX"
},
{
id: "bicep",
scopeName: "source.bicep",
path: "bicep.tmLanguage.json",
displayName: "Bicep",
samplePath: "bicep.sample"
},
{
id: "blade",
scopeName: "text.html.php.blade",
path: "blade.tmLanguage.json",
displayName: "Blade",
samplePath: "blade.sample",
embeddedLangs: ["html", "xml", "sql", "javascript", "json", "css"]
},
{
id: "c",
scopeName: "source.c",
path: "c.tmLanguage.json",
displayName: "C",
samplePath: "c.sample"
},
{
id: "cadence",
scopeName: "source.cadence",
path: "cadence.tmLanguage.json",
displayName: "Cadence",
samplePath: "cadence.sample",
aliases: ["cdc"]
},
{
id: "clarity",
scopeName: "source.clar",
path: "clarity.tmLanguage.json",
displayName: "Clarity",
samplePath: "clarity.sample"
},
{
id: "clojure",
scopeName: "source.clojure",
path: "clojure.tmLanguage.json",
displayName: "Clojure",
samplePath: "clojure.sample",
aliases: ["clj"]
},
{
id: "cmake",
scopeName: "source.cmake",
path: "cmake.tmLanguage.json",
displayName: "CMake",
samplePath: "cmake.sample"
},
{
id: "cobol",
scopeName: "source.cobol",
path: "cobol.tmLanguage.json",
displayName: "COBOL",
samplePath: "cobol.sample",
embeddedLangs: ["sql", "html", "java"]
},
{
id: "codeql",
scopeName: "source.ql",
path: "codeql.tmLanguage.json",
displayName: "CodeQL",
samplePath: "codeql.sample",
aliases: ["ql"],
embeddedLangs: ["markdown"]
},
{
id: "coffee",
scopeName: "source.coffee",
path: "coffee.tmLanguage.json",
displayName: "CoffeeScript",
samplePath: "coffee.sample",
embeddedLangs: ["javascript"]
},
{
id: "cpp",
scopeName: "source.cpp",
path: "cpp.tmLanguage.json",
displayName: "C++",
samplePath: "cpp.sample",
embeddedLangs: ["glsl", "sql"]
},
{
id: "crystal",
scopeName: "source.crystal",
path: "crystal.tmLanguage.json",
displayName: "Crystal",
samplePath: "crystal.sample",
embeddedLangs: ["html", "sql", "css", "c", "javascript", "shellscript"]
},
{
id: "csharp",
scopeName: "source.cs",
path: "csharp.tmLanguage.json",
displayName: "C#",
samplePath: "csharp.sample",
aliases: ["c#", "cs"]
},
{
id: "css",
scopeName: "source.css",
path: "css.tmLanguage.json",
displayName: "CSS",
samplePath: "css.sample"
},
{
id: "cue",
scopeName: "source.cue",
path: "cue.tmLanguage.json",
displayName: "CUE",
samplePath: "cue.sample"
},
{
id: "cypher",
scopeName: "source.cypher",
path: "cypher.tmLanguage.json",
displayName: "Cypher",
samplePath: "cypher.sample",
aliases: ["cql"]
},
{
id: "d",
scopeName: "source.d",
path: "d.tmLanguage.json",
displayName: "D",
samplePath: "d.sample"
},
{
id: "dart",
scopeName: "source.dart",
path: "dart.tmLanguage.json",
displayName: "Dart",
samplePath: "dart.sample"
},
{
id: "dax",
scopeName: "source.dax",
path: "dax.tmLanguage.json",
displayName: "DAX",
samplePath: "dax.sample"
},
{
id: "diff",
scopeName: "source.diff",
path: "diff.tmLanguage.json",
displayName: "Diff",
samplePath: "diff.sample"
},
{
id: "docker",
scopeName: "source.dockerfile",
path: "docker.tmLanguage.json",
displayName: "Docker",
samplePath: "docker.sample",
aliases: ["dockerfile"]
},
{
id: "dream-maker",
scopeName: "source.dm",
path: "dream-maker.tmLanguage.json",
displayName: "Dream Maker"
},
{
id: "elixir",
scopeName: "source.elixir",
path: "elixir.tmLanguage.json",
displayName: "Elixir",
samplePath: "elixir.sample",
embeddedLangs: ["html"]
},
{
id: "elm",
scopeName: "source.elm",
path: "elm.tmLanguage.json",
displayName: "Elm",
samplePath: "elm.sample",
embeddedLangs: ["glsl"]
},
{
id: "erb",
scopeName: "text.html.erb",
path: "erb.tmLanguage.json",
displayName: "ERB",
samplePath: "erb.sample",
embeddedLangs: ["html", "ruby"]
},
{
id: "erlang",
scopeName: "source.erlang",
path: "erlang.tmLanguage.json",
displayName: "Erlang",
samplePath: "erlang.sample",
aliases: ["erl"]
},
{
id: "fish",
scopeName: "source.fish",
path: "fish.tmLanguage.json",
displayName: "Fish",
samplePath: "fish.sample"
},
{
id: "fsharp",
scopeName: "source.fsharp",
path: "fsharp.tmLanguage.json",
displayName: "F#",
samplePath: "fsharp.sample",
aliases: ["f#", "fs"],
embeddedLangs: ["markdown"]
},
{
id: "gdresource",
scopeName: "source.gdresource",
path: "gdresource.tmLanguage.json",
displayName: "GDResource",
samplePath: "gdresource.sample",
embeddedLangs: ["gdshader", "gdscript"]
},
{
id: "gdscript",
scopeName: "source.gdscript",
path: "gdscript.tmLanguage.json",
displayName: "GDScript",
samplePath: "gdscript.sample"
},
{
id: "gdshader",
scopeName: "source.gdshader",
path: "gdshader.tmLanguage.json",
displayName: "GDShader",
samplePath: "gdshader.sample"
},
{
id: "gherkin",
scopeName: "text.gherkin.feature",
path: "gherkin.tmLanguage.json",
displayName: "Gherkin"
},
{
id: "git-commit",
scopeName: "text.git-commit",
path: "git-commit.tmLanguage.json",
displayName: "Git Commit Message",
embeddedLangs: ["diff"]
},
{
id: "git-rebase",
scopeName: "text.git-rebase",
path: "git-rebase.tmLanguage.json",
displayName: "Git Rebase Message",
embeddedLangs: ["shellscript"]
},
{
id: "glimmer-js",
scopeName: "source.gjs",
path: "glimmer-js.tmLanguage.json",
displayName: "Glimmer JS",
aliases: ["gjs"],
embeddedLangs: ["javascript", "handlebars"]
},
{
id: "glimmer-ts",
scopeName: "source.gts",
path: "glimmer-ts.tmLanguage.json",
displayName: "Glimmer TS",
aliases: ["gts"],
embeddedLangs: ["typescript", "handlebars"]
},
{
id: "glsl",
scopeName: "source.glsl",
path: "glsl.tmLanguage.json",
displayName: "GLSL",
samplePath: "glsl.sample",
embeddedLangs: ["c"]
},
{
id: "gnuplot",
scopeName: "source.gnuplot",
path: "gnuplot.tmLanguage.json",
displayName: "Gnuplot"
},
{
id: "go",
scopeName: "source.go",
path: "go.tmLanguage.json",
displayName: "Go",
samplePath: "go.sample"
},
{
id: "graphql",
scopeName: "source.graphql",
path: "graphql.tmLanguage.json",
displayName: "GraphQL",
embeddedLangs: ["javascript", "typescript", "jsx", "tsx"]
},
{
id: "groovy",
scopeName: "source.groovy",
path: "groovy.tmLanguage.json",
displayName: "Groovy"
},
{
id: "hack",
scopeName: "source.hack",
path: "hack.tmLanguage.json",
displayName: "Hack",
embeddedLangs: ["html", "sql"]
},
{
id: "haml",
scopeName: "text.haml",
path: "haml.tmLanguage.json",
displayName: "Ruby Haml",
embeddedLangs: ["ruby", "javascript", "sass", "coffee", "markdown", "css"]
},
{
id: "handlebars",
scopeName: "text.html.handlebars",
path: "handlebars.tmLanguage.json",
displayName: "Handlebars",
aliases: ["hbs"],
embeddedLangs: ["html", "css", "javascript", "yaml"]
},
{
id: "haskell",
scopeName: "source.haskell",
path: "haskell.tmLanguage.json",
displayName: "Haskell",
aliases: ["hs"]
},
{
id: "hcl",
scopeName: "source.hcl",
path: "hcl.tmLanguage.json",
displayName: "HashiCorp HCL",
samplePath: "hcl.sample"
},
{
id: "hjson",
scopeName: "source.hjson",
path: "hjson.tmLanguage.json",
displayName: "Hjson",
samplePath: "hjson.sample"
},
{
id: "hlsl",
scopeName: "source.hlsl",
path: "hlsl.tmLanguage.json",
displayName: "HLSL"
},
{
id: "html",
scopeName: "text.html.basic",
path: "html.tmLanguage.json",
displayName: "HTML",
samplePath: "html.sample",
embeddedLangs: ["javascript", "css"]
},
{
id: "http",
scopeName: "source.http",
path: "http.tmLanguage.json",
displayName: "HTTP",
samplePath: "http.sample",
embeddedLangs: ["shellscript", "json", "xml", "graphql"]
},
{
id: "imba",
scopeName: "source.imba",
path: "imba.tmLanguage.json",
displayName: "Imba",
samplePath: "imba.sample"
},
{
id: "ini",
scopeName: "source.ini",
path: "ini.tmLanguage.json",
displayName: "INI",
aliases: ["properties"]
},
{
id: "java",
scopeName: "source.java",
path: "java.tmLanguage.json",
displayName: "Java",
samplePath: "java.sample"
},
{
id: "javascript",
scopeName: "source.js",
path: "javascript.tmLanguage.json",
displayName: "JavaScript",
samplePath: "javascript.sample",
aliases: ["js"]
},
{
id: "jinja-html",
scopeName: "text.html.jinja",
path: "jinja-html.tmLanguage.json",
displayName: "Jinja",
embeddedLangs: ["html"]
},
{
id: "jison",
scopeName: "source.jison",
path: "jison.tmLanguage.json",
displayName: "Jison",
samplePath: "jison.sample",
embeddedLangs: ["javascript"]
},
{
id: "json",
scopeName: "source.json",
path: "json.tmLanguage.json",
displayName: "JSON"
},
{
id: "json5",
scopeName: "source.json5",
path: "json5.tmLanguage.json",
displayName: "JSON5",
samplePath: "json5.sample"
},
{
id: "jsonc",
scopeName: "source.json.comments",
path: "jsonc.tmLanguage.json",
displayName: "JSON with Comments"
},
{
id: "jsonl",
scopeName: "source.json.lines",
path: "jsonl.tmLanguage.json",
displayName: "JSON Lines"
},
{
id: "jsonnet",
scopeName: "source.jsonnet",
path: "jsonnet.tmLanguage.json",
displayName: "Jsonnet"
},
{
id: "jssm",
scopeName: "source.jssm",
path: "jssm.tmLanguage.json",
displayName: "JSSM",
samplePath: "jssm.sample",
aliases: ["fsl"]
},
{
id: "jsx",
scopeName: "source.js.jsx",
path: "jsx.tmLanguage.json",
displayName: "JSX"
},
{
id: "julia",
scopeName: "source.julia",
path: "julia.tmLanguage.json",
displayName: "Julia",
embeddedLangs: ["cpp", "python", "javascript", "r", "sql"]
},
{
id: "kotlin",
scopeName: "source.kotlin",
path: "kotlin.tmLanguage.json",
displayName: "Kotlin",
samplePath: "kotlin.sample"
},
{
id: "kusto",
scopeName: "source.kusto",
path: "kusto.tmLanguage.json",
displayName: "Kusto",
samplePath: "kusto.sample",
aliases: ["kql"]
},
{
id: "latex",
scopeName: "text.tex.latex",
path: "latex.tmLanguage.json",
displayName: "LaTeX",
embeddedLangs: ["tex", "css", "haskell", "html", "xml", "java", "lua", "julia", "ruby", "javascript", "typescript", "python", "yaml", "rust", "scala", "gnuplot"]
},
{
id: "less",
scopeName: "source.css.less",
path: "less.tmLanguage.json",
displayName: "Less",
embeddedLangs: ["css"]
},
{
id: "liquid",
scopeName: "text.html.liquid",
path: "liquid.tmLanguage.json",
displayName: "Liquid",
samplePath: "liquid.sample",
embeddedLangs: ["html", "css", "json", "javascript"]
},
{
id: "lisp",
scopeName: "source.lisp",
path: "lisp.tmLanguage.json",
displayName: "Lisp"
},
{
id: "logo",
scopeName: "source.logo",
path: "logo.tmLanguage.json",
displayName: "Logo"
},
{
id: "lua",
scopeName: "source.lua",
path: "lua.tmLanguage.json",
displayName: "Lua",
embeddedLangs: ["c"]
},
{
id: "make",
scopeName: "source.makefile",
path: "make.tmLanguage.json",
displayName: "Makefile",
aliases: ["makefile"]
},
{
id: "markdown",
scopeName: "text.html.markdown",
path: "markdown.tmLanguage.json",
displayName: "Markdown",
aliases: ["md"],
embeddedLangs: ["css", "html", "ini", "java", "lua", "make", "perl", "r", "ruby", "php", "sql", "vb", "xml", "xsl", "yaml", "bat", "clojure", "coffee", "c", "cpp", "diff", "docker", "git-commit", "git-rebase", "go", "groovy", "pug", "javascript", "json", "jsonc", "less", "objective-c", "swift", "scss", "raku", "powershell", "python", "julia", "rust", "scala", "shellscript", "typescript", "tsx", "csharp", "fsharp", "dart", "handlebars", "erlang", "elixir", "latex", "bibtex"]
},
{
id: "marko",
scopeName: "text.marko",
path: "marko.tmLanguage.json",
displayName: "Marko",
embeddedLangs: ["css", "less", "scss", "javascript"]
},
{
id: "matlab",
scopeName: "source.matlab",
path: "matlab.tmLanguage.json",
displayName: "MATLAB"
},
{
id: "mdx",
scopeName: "source.mdx",
path: "mdx.tmLanguage.json",
displayName: "MDX",
embeddedLangs: ["tsx", "toml", "yaml", "c", "clojure", "coffee", "cpp", "csharp", "css", "diff", "docker", "elixir", "elm", "erlang", "go", "graphql", "haskell", "html", "ini", "java", "javascript", "json", "julia", "kotlin", "less", "lua", "make", "markdown", "objective-c", "perl", "python", "r", "ruby", "rust", "scala", "scss", "shellscript", "sql", "xml", "swift", "typescript"]
},
{
id: "mermaid",
scopeName: "source.mermaid",
path: "mermaid.tmLanguage.json",
displayName: "Mermaid"
},
{
id: "narrat",
scopeName: "source.narrat",
path: "narrat.tmLanguage.json",
displayName: "Narrat Language",
samplePath: "narrat.sample",
aliases: ["nar"]
},
{
id: "nextflow",
scopeName: "source.nextflow",
path: "nextflow.tmLanguage.json",
displayName: "Nextflow",
samplePath: "nextflow.sample",
aliases: ["nf"]
},
{
id: "nginx",
scopeName: "source.nginx",
path: "nginx.tmLanguage.json",
displayName: "Nginx",
embeddedLangs: ["lua"]
},
{
id: "nim",
scopeName: "source.nim",
path: "nim.tmLanguage.json",
displayName: "Nim",
embeddedLangs: ["c", "html", "xml", "javascript", "css", "glsl", "markdown"]
},
{
id: "nix",
scopeName: "source.nix",
path: "nix.tmLanguage.json",
displayName: "Nix"
},
{
id: "objective-c",
scopeName: "source.objc",
path: "objective-c.tmLanguage.json",
displayName: "Objective-C",
aliases: ["objc"]
},
{
id: "objective-cpp",
scopeName: "source.objcpp",
path: "objective-cpp.tmLanguage.json",
displayName: "Objective-C++"
},
{
id: "ocaml",
scopeName: "source.ocaml",
path: "ocaml.tmLanguage.json",
displayName: "OCaml"
},
{
id: "pascal",
scopeName: "source.pascal",
path: "pascal.tmLanguage.json",
displayName: "Pascal"
},
{
id: "perl",
scopeName: "source.perl",
path: "perl.tmLanguage.json",
displayName: "Perl",
embeddedLangs: ["html", "xml", "css", "javascript", "sql"]
},
{
id: "php",
scopeName: "source.php",
path: "php.tmLanguage.json",
displayName: "PHP",
embeddedLangs: ["html", "xml", "sql", "javascript", "json", "css"]
},
{
id: "plsql",
scopeName: "source.plsql.oracle",
path: "plsql.tmLanguage.json",
displayName: "PL/SQL"
},
{
id: "postcss",
scopeName: "source.css.postcss",
path: "postcss.tmLanguage.json",
displayName: "PostCSS"
},
{
id: "powerquery",
scopeName: "source.powerquery",
path: "powerquery.tmLanguage.json",
displayName: "PowerQuery",
samplePath: "powerquery.sample"
},
{
id: "powershell",
scopeName: "source.powershell",
path: "powershell.tmLanguage.json",
displayName: "PowerShell",
aliases: ["ps", "ps1"]
},
{
id: "prisma",
scopeName: "source.prisma",
path: "prisma.tmLanguage.json",
displayName: "Prisma",
samplePath: "prisma.sample"
},
{
id: "prolog",
scopeName: "source.prolog",
path: "prolog.tmLanguage.json",
displayName: "Prolog"
},
{
id: "proto",
scopeName: "source.proto",
path: "proto.tmLanguage.json",
displayName: "Protocol Buffer 3",
samplePath: "proto.sample"
},
{
id: "pug",
scopeName: "text.pug",
path: "pug.tmLanguage.json",
displayName: "Pug",
aliases: ["jade"],
embeddedLangs: ["javascript", "css", "sass", "scss", "stylus", "coffee", "html"]
},
{
id: "puppet",
scopeName: "source.puppet",
path: "puppet.tmLanguage.json",
displayName: "Puppet"
},
{
id: "purescript",
scopeName: "source.purescript",
path: "purescript.tmLanguage.json",
displayName: "PureScript"
},
{
id: "python",
scopeName: "source.python",
path: "python.tmLanguage.json",
displayName: "Python",
samplePath: "python.sample",
aliases: ["py"]
},
{
id: "r",
scopeName: "source.r",
path: "r.tmLanguage.json",
displayName: "R"
},
{
id: "raku",
scopeName: "source.perl.6",
path: "raku.tmLanguage.json",
displayName: "Perl 6",
aliases: ["perl6"]
},
{
id: "razor",
scopeName: "text.aspnetcorerazor",
path: "razor.tmLanguage.json",
displayName: "ASP.NET Razor",
embeddedLangs: ["html", "csharp"]
},
{
id: "reg",
scopeName: "source.reg",
path: "reg.tmLanguage.json",
displayName: "Windows Registry Script",
samplePath: "reg.sample"
},
{
id: "rel",
scopeName: "source.rel",
path: "rel.tmLanguage.json",
displayName: "Rel",
samplePath: "rel.sample"
},
{
id: "riscv",
scopeName: "source.riscv",
path: "riscv.tmLanguage.json",
displayName: "RISC-V"
},
{
id: "rst",
scopeName: "source.rst",
path: "rst.tmLanguage.json",
displayName: "reStructuredText",
embeddedLangs: ["cpp", "python", "javascript", "shellscript", "yaml", "cmake", "ruby"]
},
{
id: "ruby",
scopeName: "source.ruby",
path: "ruby.tmLanguage.json",
displayName: "Ruby",
samplePath: "ruby.sample",
aliases: ["rb"],
embeddedLangs: ["html", "xml", "sql", "css", "c", "javascript", "shellscript", "lua"]
},
{
id: "rust",
scopeName: "source.rust",
path: "rust.tmLanguage.json",
displayName: "Rust",
aliases: ["rs"]
},
{
id: "sas",
scopeName: "source.sas",
path: "sas.tmLanguage.json",
displayName: "SAS",
embeddedLangs: ["sql"]
},
{
id: "sass",
scopeName: "source.sass",
path: "sass.tmLanguage.json",
displayName: "Sass"
},
{
id: "scala",
scopeName: "source.scala",
path: "scala.tmLanguage.json",
displayName: "Scala"
},
{
id: "scheme",
scopeName: "source.scheme",
path: "scheme.tmLanguage.json",
displayName: "Scheme"
},
{
id: "scss",
scopeName: "source.css.scss",
path: "scss.tmLanguage.json",
displayName: "SCSS",
embeddedLangs: ["css"]
},
{
id: "shaderlab",
scopeName: "source.shaderlab",
path: "shaderlab.tmLanguage.json",
displayName: "ShaderLab",
aliases: ["shader"],
embeddedLangs: ["hlsl"]
},
{
id: "shellscript",
scopeName: "source.shell",
path: "shellscript.tmLanguage.json",
displayName: "Shell",
aliases: ["bash", "console", "sh", "shell", "zsh"]
},
{
id: "smalltalk",
scopeName: "source.smalltalk",
path: "smalltalk.tmLanguage.json",
displayName: "Smalltalk"
},
{
id: "solidity",
scopeName: "source.solidity",
path: "solidity.tmLanguage.json",
displayName: "Solidity"
},
{
id: "sparql",
scopeName: "source.sparql",
path: "sparql.tmLanguage.json",
displayName: "SPARQL",
samplePath: "sparql.sample",
embeddedLangs: ["turtle"]
},
{
id: "sql",
scopeName: "source.sql",
path: "sql.tmLanguage.json",
displayName: "SQL"
},
{
id: "ssh-config",
scopeName: "source.ssh-config",
path: "ssh-config.tmLanguage.json",
displayName: "SSH Config"
},
{
id: "stata",
scopeName: "source.stata",
path: "stata.tmLanguage.json",
displayName: "Stata",
samplePath: "stata.sample",
embeddedLangs: ["sql"]
},
{
id: "stylus",
scopeName: "source.stylus",
path: "stylus.tmLanguage.json",
displayName: "Stylus",
aliases: ["styl"]
},
{
id: "svelte",
scopeName: "source.svelte",
path: "svelte.tmLanguage.json",
displayName: "Svelte",
embeddedLangs: ["javascript", "typescript", "coffee", "stylus", "sass", "css", "scss", "less", "postcss", "pug", "markdown"]
},
{
id: "swift",
scopeName: "source.swift",
path: "swift.tmLanguage.json",
displayName: "Swift"
},
{
id: "system-verilog",
scopeName: "source.systemverilog",
path: "system-verilog.tmLanguage.json",
displayName: "SystemVerilog"
},
{
id: "tasl",
scopeName: "source.tasl",
path: "tasl.tmLanguage.json",
displayName: "Tasl",
samplePath: "tasl.sample"
},
{
id: "tcl",
scopeName: "source.tcl",
path: "tcl.tmLanguage.json",
displayName: "Tcl"
},
{
id: "tex",
scopeName: "text.tex",
path: "tex.tmLanguage.json",
displayName: "TeX",
embeddedLangs: ["r"]
},
{
id: "toml",
scopeName: "source.toml",
path: "toml.tmLanguage.json",
displayName: "TOML"
},
{
id: "tsx",
scopeName: "source.tsx",
path: "tsx.tmLanguage.json",
displayName: "TSX",
samplePath: "tsx.sample"
},
{
id: "turtle",
scopeName: "source.turtle",
path: "turtle.tmLanguage.json",
displayName: "Turtle",
samplePath: "turtle.sample"
},
{
id: "twig",
scopeName: "text.html.twig",
path: "twig.tmLanguage.json",
displayName: "Twig",
embeddedLangs: ["css", "javascript", "php", "python", "ruby"]
},
{
id: "typescript",
scopeName: "source.ts",
path: "typescript.tmLanguage.json",
displayName: "TypeScript",
aliases: ["ts"]
},
{
id: "v",
scopeName: "source.v",
path: "v.tmLanguage.json",
displayName: "V",
samplePath: "v.sample"
},
{
id: "vb",
scopeName: "source.asp.vb.net",
path: "vb.tmLanguage.json",
displayName: "Visual Basic",
aliases: ["cmd"]
},
{
id: "verilog",
scopeName: "source.verilog",
path: "verilog.tmLanguage.json",
displayName: "Verilog"
},
{
id: "vhdl",
scopeName: "source.vhdl",
path: "vhdl.tmLanguage.json",
displayName: "VHDL"
},
{
id: "viml",
scopeName: "source.viml",
path: "viml.tmLanguage.json",
displayName: "Vim Script",
aliases: ["vim", "vimscript"]
},
{
id: "vue-html",
scopeName: "text.html.vue-html",
path: "vue-html.tmLanguage.json",
displayName: "Vue HTML",
embeddedLangs: ["vue", "javascript"]
},
{
id: "vue",
scopeName: "source.vue",
path: "vue.tmLanguage.json",
displayName: "Vue",
embeddedLangs: ["html", "markdown", "pug", "stylus", "sass", "css", "scss", "less", "javascript", "typescript", "jsx", "tsx", "json", "jsonc", "json5", "yaml", "toml", "graphql"]
},
{
id: "vyper",
scopeName: "source.vyper",
path: "vyper.tmLanguage.json",
displayName: "Vyper",
samplePath: "vyper.sample",
aliases: ["vy"]
},
{
id: "wasm",
scopeName: "source.wat",
path: "wasm.tmLanguage.json",
displayName: "WebAssembly"
},
{
id: "wenyan",
scopeName: "source.wenyan",
path: "wenyan.tmLanguage.json",
displayName: "Wenyan",
aliases: ["\u6587\u8A00"]
},
{
id: "wgsl",
scopeName: "source.wgsl",
path: "wgsl.tmLanguage.json",
displayName: "WGSL",
samplePath: "wgsl.sample"
},
{
id: "wolfram",
scopeName: "source.wolfram",
path: "wolfram.tmLanguage.json",
displayName: "Wolfram",
samplePath: "wolfram.sample"
},
{
id: "xml",
scopeName: "text.xml",
path: "xml.tmLanguage.json",
displayName: "XML",
embeddedLangs: ["java"]
},
{
id: "xsl",
scopeName: "text.xml.xsl",
path: "xsl.tmLanguage.json",
displayName: "XSL",
embeddedLangs: ["xml"]
},
{
id: "yaml",
scopeName: "source.yaml",
path: "yaml.tmLanguage.json",
displayName: "YAML",
aliases: ["yml"]
},
{
id: "zenscript",
scopeName: "source.zenscript",
path: "zenscript.tmLanguage.json",
displayName: "ZenScript",
samplePath: "zenscript.sample"
}
];
var FontStyle = /* @__PURE__ */ ((FontStyle2) => {
FontStyle2[FontStyle2["NotSet"] = -1] = "NotSet";
FontStyle2[FontStyle2["None"] = 0] = "None";
FontStyle2[FontStyle2["Italic"] = 1] = "Italic";
FontStyle2[FontStyle2["Bold"] = 2] = "Bold";
FontStyle2[FontStyle2["Underline"] = 4] = "Underline";
return FontStyle2;
})(FontStyle || {});
class StackElementMetadata {
static toBinaryStr(metadata) {
let r = metadata.toString(2);
while (r.length < 32) {
r = "0" + r;
}
return r;
}
static printMetadata(metadata) {
let languageId = StackElementMetadata.getLanguageId(metadata);
let tokenType = StackElementMetadata.getTokenType(metadata);
let fontStyle = StackElementMetadata.getFontStyle(metadata);
let foreground = StackElementMetadata.getForeground(metadata);
let background = StackElementMetadata.getBackground(metadata);
console.log({
languageId,
tokenType,
fontStyle,
foreground,
background
});
}
static getLanguageId(metadata) {
return (metadata & 255 /* LANGUAGEID_MASK */) >>> 0 /* LANGUAGEID_OFFSET */;
}
static getTokenType(metadata) {
return (metadata & 768 /* TOKEN_TYPE_MASK */) >>> 8 /* TOKEN_TYPE_OFFSET */;
}
static getFontStyle(metadata) {
return (metadata & 14336 /* FONT_STYLE_MASK */) >>> 11 /* FONT_STYLE_OFFSET */;
}
static getForeground(metadata) {
return (metadata & 8372224 /* FOREGROUND_MASK */) >>> 15 /* FOREGROUND_OFFSET */;
}
static getBackground(metadata) {
return (metadata & 4286578688 /* BACKGROUND_MASK */) >>> 24 /* BACKGROUND_OFFSET */;
}
static containsBalancedBrackets(metadata) {
return (metadata & 1024 /* BALANCED_BRACKETS_MASK */) !== 0;
}
static set(metadata, languageId, tokenType, fontStyle, foreground, background) {
let _languageId = StackElementMetadata.getLanguageId(metadata);
let _tokenType = StackElementMetadata.getTokenType(metadata);
let _fontStyle = StackElementMetadata.getFontStyle(metadata);
let _foreground = StackElementMetadata.getForeground(metadata);
let _background = StackElementMetadata.getBackground(metadata);
let _containsBalancedBracketsBit = StackElementMetadata.containsBalancedBrackets(
metadata
) ? 1 : 0;
if (languageId !== 0) {
_languageId = languageId;
}
if (tokenType !== 0 /* Other */) {
_tokenType = tokenType === 8 /* MetaEmbedded */ ? 0 /* Other */ : tokenType;
}
if (fontStyle !== -1 /* NotSet */) {
_fontStyle = fontStyle;
}
if (foreground !== 0) {
_foreground = foreground;
}
if (background !== 0) {
_background = background;
}
return (_languageId << 0 /* LANGUAGEID_OFFSET */ | _tokenType << 8 /* TOKEN_TYPE_OFFSET */ | _fontStyle << 11 /* FONT_STYLE_OFFSET */ | _containsBalancedBracketsBit << 10 /* BALANCED_BRACKETS_OFFSET */ | _foreground << 15 /* FOREGROUND_OFFSET */ | _background << 24 /* BACKGROUND_OFFSET */) >>> 0;
}
}
function trimEndSlash(str) {
if (str.endsWith("/") || str.endsWith("\\"))
return str.slice(0, -1);
return str;
}
function trimStartDot(str) {
if (str.startsWith("./"))
return str.slice(2);
return str;
}
function dirpathparts(str) {
const parts = str.split(/[\/\\]/g);
return parts.slice(0, parts.length - 1);
}
function join(...parts) {
return parts.map(trimEndSlash).map(trimStartDot).join("/");
}
function groupBy(elements, keyGetter) {
const map = /* @__PURE__ */ new Map();
for (const element of elements) {
const key = keyGetter(element);
if (map.has(key)) {
const group = map.get(key);
group.push(element);
} else {
map.set(key, [element]);
}
}
return map;
}
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/**
* Creates a JSON scanner on the given text.
* If ignoreTrivia is set, whitespaces or comments are ignored.
*/
function createScanner(text, ignoreTrivia = false) {
const len = text.length;
let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;
function scanHexDigits(count, exact) {
let digits = 0;
let value = 0;
while (digits < count || !exact) {
let ch = text.charCodeAt(pos);
if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
value = value * 16 + ch - 48 /* CharacterCodes._0 */;
}
else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;
}
else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;
}
else {
break;
}
pos++;
digits++;
}
if (digits < count) {
value = -1;
}
return value;
}
function setPosition(newPosition) {
pos = newPosition;
value = '';
tokenOffset = 0;
token = 16 /* SyntaxKind.Unknown */;
scanError = 0 /* ScanError.None */;
}
function scanNumber() {
let start = pos;
if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
pos++;
}
else {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
}
if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
pos++;
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
}
else {
scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
return text.substring(start, pos);
}
}
let end = pos;
if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
pos++;
if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
pos++;
}
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
end = pos;
}
else {
scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
}
}
return text.substring(start, end);
}
function scanString() {
let result = '', start = pos;
while (true) {
if (pos >= len) {
result += text.substring(start, pos);
scanError = 2 /* ScanError.UnexpectedEndOfString */;
break;
}
const ch = text.charCodeAt(pos);
if (ch === 34 /* CharacterCodes.doubleQuote */) {
result += text.substring(start, pos);
pos++;
break;
}
if (ch === 92 /* CharacterCodes.backslash */) {
result += text.substring(start, pos);
pos++;
if (pos >= len) {
scanError = 2 /* ScanError.UnexpectedEndOfString */;
break;
}
const ch2 = text.charCodeAt(pos++);
switch (ch2) {
case 34 /* CharacterCodes.doubleQuote */:
result += '\"';
break;
case 92 /* CharacterCodes.backslash */:
result += '\\';
break;
case 47 /* CharacterCodes.slash */:
result += '/';
break;
case 98 /* CharacterCodes.b */:
result += '\b';
break;
case 102 /* CharacterCodes.f */:
result += '\f';
break;
case 110 /* CharacterCodes.n */:
result += '\n';
break;
case 114 /* CharacterCodes.r */:
result += '\r';
break;
case 116 /* CharacterCodes.t */:
result += '\t';
break;
case 117 /* CharacterCodes.u */:
const ch3 = scanHexDigits(4, true);
if (ch3 >= 0) {
result += String.fromCharCode(ch3);
}
else {
scanError = 4 /* ScanError.InvalidUnicode */;
}
break;
default:
scanError = 5 /* ScanError.InvalidEscapeCharacter */;
}
start = pos;
continue;
}
if (ch >= 0 && ch <= 0x1f) {
if (isLineBreak(ch)) {
result += text.substring(start, pos);
scanError = 2 /* ScanError.UnexpectedEndOfString */;
break;
}
else {
scanError = 6 /* ScanError.InvalidCharacter */;
// mark as error but continue with string
}
}
pos++;
}
return result;
}
function scanNext() {
value = '';
scanError = 0 /* ScanError.None */;
tokenOffset = pos;
lineStartOffset = lineNumber;
prevTokenLineStartOffset = tokenLineStartOffset;
if (pos >= len) {
// at the end
tokenOffset = len;
return token = 17 /* SyntaxKind.EOF */;
}
let code = text.charCodeAt(pos);
// trivia: whitespace
if (isWhiteSpace(code)) {
do {
pos++;
value += String.fromCharCode(code);
code = text.charCodeAt(pos);
} while (isWhiteSpace(code));
return token = 15 /* SyntaxKind.Trivia */;
}
// trivia: newlines
if (isLineBreak(code)) {
pos++;
value += String.fromCharCode(code);
if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
pos++;
value += '\n';
}
lineNumber++;
tokenLineStartOffset = pos;
return token = 14 /* SyntaxKind.LineBreakTrivia */;
}
switch (code) {
// tokens: []{}:,
case 123 /* CharacterCodes.openBrace */:
pos++;
return token = 1 /* SyntaxKind.OpenBraceToken */;
case 125 /* CharacterCodes.closeBrace */:
pos++;
return token = 2 /* SyntaxKind.CloseBraceToken */;
case 91 /* CharacterCodes.openBracket */:
pos++;
return token = 3 /* SyntaxKind.OpenBracketToken */;
case 93 /* CharacterCodes.closeBracket */:
pos++;
return token = 4 /* SyntaxKind.CloseBracketToken */;
case 58 /* CharacterCodes.colon */:
pos++;
return token = 6 /* SyntaxKind.ColonToken */;
case 44 /* CharacterCodes.comma */:
pos++;
return token = 5 /* SyntaxKind.CommaToken */;
// strings
case 34 /* CharacterCodes.doubleQuote */:
pos++;
value = scanString();
return token = 10 /* SyntaxKind.StringLiteral */;
// comments
case 47 /* CharacterCodes.slash */:
const start = pos - 1;
// Single-line comment
if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
pos += 2;
while (pos < len) {
if (isLineBreak(text.charCodeAt(pos))) {
break;
}
pos++;
}
value = text.substring(start, pos);
return token = 12 /* SyntaxKind.LineCommentTrivia */;
}
// Multi-line comment
if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
pos += 2;
const safeLength = len - 1; // For lookahead.
let commentClosed = false;
while (pos < safeLength) {
const ch = text.charCodeAt(pos);
if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
pos += 2;
commentClosed = true;
break;
}
pos++;
if (isLineBreak(ch)) {
if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
pos++;
}
lineNumber++;
tokenLineStartOffset = pos;
}
}
if (!commentClosed) {
pos++;
scanError = 1 /* ScanError.UnexpectedEndOfComment */;
}
value = text.substring(start, pos);
return token = 13 /* SyntaxKind.BlockCommentTrivia */;
}
// just a single slash
value += String.fromCharCode(code);
pos++;
return token = 16 /* SyntaxKind.Unknown */;
// numbers
case 45 /* CharacterCodes.minus */:
value += String.fromCharCode(code);
pos++;
if (pos === len || !isDigit(text.charCodeAt(pos))) {
return token = 16 /* SyntaxKind.Unknown */;
}
// found a minus, followed by a number so
// we fall through to proceed with scanning
// numbers
case 48 /* CharacterCodes._0 */:
case 49 /* CharacterCodes._1 */:
case 50 /* CharacterCodes._2 */:
case 51 /* CharacterCodes._3 */:
case 52 /* CharacterCodes._4 */:
case 53 /* CharacterCodes._5 */:
case 54 /* CharacterCodes._6 */:
case 55 /* CharacterCodes._7 */:
case 56 /* CharacterCodes._8 */:
case 57 /* CharacterCodes._9 */:
value += scanNumber();
return token = 11 /* SyntaxKind.NumericLiteral */;
// literals and unknown symbols
default:
// is a literal? Read the full word.
while (pos < len && isUnknownContentCharacter(code)) {
pos++;
code = text.charCodeAt(pos);
}
if (tokenOffset !== pos) {
value = text.substring(tokenOffset, pos);
// keywords: true, false, null
switch (value) {
case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
}
return token = 16 /* SyntaxKind.Unknown */;
}
// some
value += String.fromCharCode(code);
pos++;
return token = 16 /* SyntaxKind.Unknown */;
}
}
function isUnknownContentCharacter(code) {
if (isWhiteSpace(code) || isLineBreak(code)) {
return false;
}
switch (code) {
case 125 /* CharacterCodes.closeBrace */:
case 93 /* CharacterCodes.closeBracket */:
case 123 /* CharacterCodes.openBrace */:
case 91 /* CharacterCodes.openBracket */:
case 34 /* CharacterCodes.doubleQuote */:
case 58 /* CharacterCodes.colon */:
case 44 /* CharacterCodes.comma */:
case 47 /* CharacterCodes.slash */:
return false;
}
return true;
}
function scanNextNonTrivia() {
let result;
do {
result = scanNext();
} while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
return result;
}
return {
setPosition: setPosition,
getPosition: () => pos,
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
getToken: () => token,
getTokenValue: () => value,
getTokenOffset: () => tokenOffset,
getTokenLength: () => pos - tokenOffset,
getTokenStartLine: () => lineStartOffset,
getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
getTokenError: () => scanError,
};
}
function isWhiteSpace(ch) {
return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;
}
function isLineBreak(ch) {
return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;
}
function isDigit(ch) {
return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
}
var CharacterCodes;
(function (CharacterCodes) {
CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
CharacterCodes[CharacterCodes["space"] = 32] = "space";
CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
CharacterCodes[CharacterCodes["a"] = 97] = "a";
CharacterCodes[CharacterCodes["b"] = 98] = "b";
CharacterCodes[CharacterCodes["c"] = 99] = "c";
CharacterCodes[CharacterCodes["d"] = 100] = "d";
CharacterCodes[CharacterCodes["e"] = 101] = "e";
CharacterCodes[CharacterCodes["f"] = 102] = "f";
CharacterCodes[CharacterCodes["g"] = 103] = "g";
CharacterCodes[CharacterCodes["h"] = 104] = "h";
CharacterCodes[CharacterCodes["i"] = 105] = "i";
CharacterCodes[CharacterCodes["j"] = 106] = "j";
CharacterCodes[CharacterCodes["k"] = 107] = "k";
CharacterCodes[CharacterCodes["l"] = 108] = "l";
CharacterCodes[CharacterCodes["m"] = 109] = "m";
CharacterCodes[CharacterCodes["n"] = 110] = "n";
CharacterCodes[CharacterCodes["o"] = 111] = "o";
CharacterCodes[CharacterCodes["p"] = 112] = "p";
CharacterCodes[CharacterCodes["q"] = 113] = "q";
CharacterCodes[CharacterCodes["r"] = 114] = "r";
CharacterCodes[CharacterCodes["s"] = 115] = "s";
CharacterCodes[CharacterCodes["t"] = 116] = "t";
CharacterCodes[CharacterCodes["u"] = 117] = "u";
CharacterCodes[CharacterCodes["v"] = 118] = "v";
CharacterCodes[CharacterCodes["w"] = 119] = "w";
CharacterCodes[CharacterCodes["x"] = 120] = "x";
CharacterCodes[CharacterCodes["y"] = 121] = "y";
CharacterCodes[CharacterCodes["z"] = 122] = "z";
CharacterCodes[CharacterCodes["A"] = 65] = "A";
CharacterCodes[CharacterCodes["B"] = 66] = "B";
CharacterCodes[CharacterCodes["C"] = 67] = "C";
CharacterCodes[CharacterCodes["D"] = 68] = "D";
CharacterCodes[CharacterCodes["E"] = 69] = "E";
CharacterCodes[CharacterCodes["F"] = 70] = "F";
CharacterCodes[CharacterCodes["G"] = 71] = "G";
CharacterCodes[CharacterCodes["H"] = 72] = "H";
CharacterCodes[CharacterCodes["I"] = 73] = "I";
CharacterCodes[CharacterCodes["J"] = 74] = "J";
CharacterCodes[CharacterCodes["K"] = 75] = "K";
CharacterCodes[CharacterCodes["L"] = 76] = "L";
CharacterCodes[CharacterCodes["M"] = 77] = "M";
CharacterCodes[CharacterCodes["N"] = 78] = "N";
CharacterCodes[CharacterCodes["O"] = 79] = "O";
CharacterCodes[CharacterCodes["P"] = 80] = "P";
CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
CharacterCodes[CharacterCodes["R"] = 82] = "R";
CharacterCodes[CharacterCodes["S"] = 83] = "S";
CharacterCodes[CharacterCodes["T"] = 84] = "T";
CharacterCodes[CharacterCodes["U"] = 85] = "U";
CharacterCodes[CharacterCodes["V"] = 86] = "V";
CharacterCodes[CharacterCodes["W"] = 87] = "W";
CharacterCodes[CharacterCodes["X"] = 88] = "X";
CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
})(CharacterCodes || (CharacterCodes = {}));
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var ParseOptions;
(function (ParseOptions) {
ParseOptions.DEFAULT = {
allowTrailingComma: false
};
})(ParseOptions || (ParseOptions = {}));
/**
* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
* Therefore always check the errors list to find out if the input was valid.
*/
function parse$1(text, errors = [], options = ParseOptions.DEFAULT) {
let currentProperty = null;
let currentParent = [];
const previousParents = [];
function onValue(value) {
if (Array.isArray(currentParent)) {
currentParent.push(value);
}
else if (currentProperty !== null) {
currentParent[currentProperty] = value;
}
}
const visitor = {
onObjectBegin: () => {
const object = {};
onValue(object);
previousParents.push(currentParent);
currentParent = object;
currentProperty = null;
},
onObjectProperty: (name) => {
currentProperty = name;
},
onObjectEnd: () => {
currentParent = previousParents.pop();
},
onArrayBegin: () => {
const array = [];
onValue(array);
previousParents.push(currentParent);
currentParent = array;
currentProperty = null;
},
onArrayEnd: () => {
currentParent = previousParents.pop();
},
onLiteralValue: onValue,
onError: (error, offset, length) => {
errors.push({ error, offset, length });
}
};
visit(text, visitor, options);
return currentParent[0];
}
/**
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
*/
function visit(text, visitor, options = ParseOptions.DEFAULT) {
const _scanner = createScanner(text, false);
// Important: Only pass copies of this to visitor functions to prevent accidental modification, and
// to not affect visitor functions which stored a reference to a previous JSONPath
const _jsonPath = [];
function toNoArgVisit(visitFunction) {
return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
}
function toNoArgVisitWithPath(visitFunction) {
return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
}
function toOneArgVisit(visitFunction) {
return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
}
function toOneArgVisitWithPath(visitFunction) {
return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
}
const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
const disallowComments = options && options.disallowComments;
const allowTrailingComma = options && options.allowTrailingComma;
function scanNext() {
while (true) {
const token = _scanner.scan();
switch (_scanner.getTokenError()) {
case 4 /* ScanError.InvalidUnicode */:
handleError(14 /* ParseErrorCode.InvalidUnicode */);
break;
case 5 /* ScanError.InvalidEscapeCharacter */:
handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
break;
case 3 /* ScanError.UnexpectedEndOfNumber */:
handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
break;
case 1 /* ScanError.UnexpectedEndOfComment */:
if (!disallowComments) {
handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
}
break;
case 2 /* ScanError.UnexpectedEndOfString */:
handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
break;
case 6 /* ScanError.InvalidCharacter */:
handleError(16 /* ParseErrorCode.InvalidCharacter */);
break;
}
switch (token) {
case 12 /* SyntaxKind.LineCommentTrivia */:
case 13 /* SyntaxKind.BlockCommentTrivia */:
if (disallowComments) {
handleError(10 /* ParseErrorCode.InvalidCommentToken */);
}
else {
onComment();
}
break;
case 16 /* SyntaxKind.Unknown */:
handleError(1 /* ParseErrorCode.InvalidSymbol */);
break;
case 15 /* SyntaxKind.Trivia */:
case 14 /* SyntaxKind.LineBreakTrivia */:
break;
default:
return token;
}
}
}
function handleError(error, skipUntilAfter = [], skipUntil = []) {
onError(error);
if (skipUntilAfter.length + skipUntil.length > 0) {
let token = _scanner.getToken();
while (token !== 17 /* SyntaxKind.EOF */) {
if (skipUntilAfter.indexOf(token) !== -1) {
scanNext();
break;
}
else if (skipUntil.indexOf(token) !== -1) {
break;
}
token = scanNext();
}
}
}
function parseString(isValue) {
const value = _scanner.getTokenValue();
if (isValue) {
onLiteralValue(value);
}
else {
onObjectProperty(value);
// add property name afterwards
_jsonPath.push(value);
}
scanNext();
return true;
}
function parseLiteral() {
switch (_scanner.getToken()) {
case 11 /* SyntaxKind.NumericLiteral */:
const tokenValue = _scanner.getTokenValue();
let value = Number(tokenValue);
if (isNaN(value)) {
handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
value = 0;
}
onLiteralValue(value);
break;
case 7 /* SyntaxKind.NullKeyword */:
onLiteralValue(null);
break;
case 8 /* SyntaxKind.TrueKeyword */:
onLiteralValue(true);
break;
case 9 /* SyntaxKind.FalseKeyword */:
onLiteralValue(false);
break;
default:
return false;
}
scanNext();
return true;
}
function parseProperty() {
if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
return false;
}
parseString(false);
if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
onSeparator(':');
scanNext(); // consume colon
if (!parseValue()) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
}
}
else {
handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
}
_jsonPath.pop(); // remove processed property name
return true;
}
function parseObject() {
onObjectBegin();
scanNext(); // consume open brace
let needsComma = false;
while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
if (!needsComma) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
}
onSeparator(',');
scanNext(); // consume comma
if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
break;
}
}
else if (needsComma) {
handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
}
if (!parseProperty()) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
}
needsComma = true;
}
onObjectEnd();
if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
}
else {
scanNext(); // consume close brace
}
return true;
}
function parseArray() {
onArrayBegin();
scanNext(); // consume open bracket
let isFirstElement = true;
let needsComma = false;
while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
if (!needsComma) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
}
onSeparator(',');
scanNext(); // consume comma
if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
break;
}
}
else if (needsComma) {
handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
}
if (isFirstElement) {
_jsonPath.push(0);
isFirstElement = false;
}
else {
_jsonPath[_jsonPath.length - 1]++;
}
if (!parseValue()) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
}
needsComma = true;
}
onArrayEnd();
if (!isFirstElement) {
_jsonPath.pop(); // remove array index
}
if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
}
else {
scanNext(); // consume close bracket
}
return true;
}
function parseValue() {
switch (_scanner.getToken()) {
case 3 /* SyntaxKind.OpenBracketToken */:
return parseArray();
case 1 /* SyntaxKind.OpenBraceToken */:
return parseObject();
case 10 /* SyntaxKind.StringLiteral */:
return parseString(true);
default:
return parseLiteral();
}
}
scanNext();
if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
if (options.allowEmptyContent) {
return true;
}
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
return false;
}
if (!parseValue()) {
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
return false;
}
if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
}
return true;
}
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var ScanError;
(function (ScanError) {
ScanError[ScanError["None"] = 0] = "None";
ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
})(ScanError || (ScanError = {}));
var SyntaxKind;
(function (SyntaxKind) {
SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
})(SyntaxKind || (SyntaxKind = {}));
/**
* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
* Therefore, always check the errors list to find out if the input was valid.
*/
const parse = parse$1;
var ParseErrorCode;
(function (ParseErrorCode) {
ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
})(ParseErrorCode || (ParseErrorCode = {}));
const isWebWorker = typeof self !== "undefined" && typeof self.WorkerGlobalScope !== "undefined";
const isNode = "process" in globalThis && typeof process !== "undefined" && typeof process.release !== "undefined" && process.release.name === "node";
const isBrowser = isWebWorker || !isNode;
let CDN_ROOT = "";
let WASM = "";
const WASM_PATH = "dist/";
function setCDN(root) {
CDN_ROOT = root.endsWith("/") ? root : root + "/";
}
function setWasm(data) {
WASM = data;
}
let _onigurumaPromise = null;
async function getOniguruma(wasmPath) {
if (!_onigurumaPromise) {
let loader;
if (isBrowser) {
if (typeof WASM === "string") {
loader = vscodeOniguruma.loadWASM({
data: await fetch(_resolvePath(join(...dirpathparts(wasmPath), "onig.wasm")))
});
} else {
loader = vscodeOniguruma.loadWASM({
data: WASM
});
}
} else {
const path = require("path");
const wasmPath2 = path.join(require.resolve("vscode-oniguruma"), "../onig.wasm");
const fs = require("fs");
const wasmBin = fs.readFileSync(wasmPath2).buffer;
loader = vscodeOniguruma.loadWASM(wasmBin);
}
_onigurumaPromise = loader.then(() => {
return {
createOnigScanner(patterns) {
return vscodeOniguruma.createOnigScanner(patterns);
},
createOnigString(s) {
return vscodeOniguruma.createOnigString(s);
}
};
});
}
return _onigurumaPromise;
}
function _resolvePath(filepath) {
if (isBrowser) {
return `${CDN_ROOT}${filepath}`;
} else {
const path = require("path");
if (path.isAbsolute(filepath)) {
return filepath;
} else {
return path.resolve(__dirname, "..", filepath);
}
}
}
async function _fetchAssets(filepath) {
const path = _resolvePath(filepath);
if (isBrowser) {
return await fetch(path).then((r) => r.text());
} else {
const fs = require("fs");
return await fs.promises.readFile(path, "utf-8");
}
}
async function _fetchJSONAssets(filepath) {
const errors = [];
const assetString = await _fetchAssets(filepath);
let rawAsset;
try {
rawAsset = JSON.parse(assetString);
} catch (e) {
rawAsset = parse(assetString, errors, {
allowTrailingComma: true
});
if (errors.length) {
throw errors[0];
}
}
return rawAsset;
}
async function fetchTheme(themePath) {
let theme = await _fetchJSONAssets(themePath);
const shikiTheme = toShikiTheme(theme);
if (shikiTheme.include) {
const includedTheme = await fetchTheme(join(...dirpathparts(themePath), shikiTheme.include));
if (includedTheme.settings) {
shikiTheme.settings = includedTheme.settings.concat(shikiTheme.settings);
}
if (includedTheme.bg && !shikiTheme.bg) {
shikiTheme.bg = includedTheme.bg;
}
if (includedTheme.colors) {
shikiTheme.colors = { ...includedTheme.colors, ...shikiTheme.colors };
}
delete shikiTheme.include;
}
return shikiTheme;
}
async function fetchGrammar(filepath) {
return await _fetchJSONAssets(filepath);
}
function repairTheme(theme) {
if (!theme.settings)
theme.settings = [];
if (theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope) {
return;
}
theme.settings.unshift({
settings: {
foreground: theme.fg,
background: theme.bg
}
});
}
function toShikiTheme(rawTheme) {
const type = rawTheme.type || "dark";
const shikiTheme = {
name: rawTheme.name,
type,
...rawTheme,
...getThemeDefaultColors(rawTheme)
};
if (rawTheme.include) {
shikiTheme.include = rawTheme.include;
}
if (rawTheme.tokenColors) {
shikiTheme.settings = rawTheme.tokenColors;
delete shikiTheme.tokenColors;
}
repairTheme(shikiTheme);
return shikiTheme;
}
const VSCODE_FALLBACK_EDITOR_FG = { light: "#333333", dark: "#bbbbbb" };
const VSCODE_FALLBACK_EDITOR_BG = { light: "#fffffe", dark: "#1e1e1e" };
function getThemeDefaultColors(theme) {
let fg, bg;
let settings = theme.settings ? theme.settings : theme.tokenColors;
const globalSetting = settings ? settings.find((s) => {
return !s.name && !s.scope;
}) : void 0;
if (globalSetting?.settings?.foreground) {
fg = globalSetting.settings.foreground;
}
if (globalSetting?.settings?.background) {
bg = globalSetting.settings.background;
}
if (!fg && theme?.colors?.["editor.foreground"]) {
fg = theme.colors["editor.foreground"];
}
if (!bg && theme?.colors?.["editor.background"]) {
bg = theme.colors["editor.background"];
}
if (!fg) {
fg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
}
if (!bg) {
bg = theme.type === "light" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
}
return {
fg,
bg
};
}
class Resolver {
constructor(onigLibPromise, onigLibName) {
this.languagesPath = "languages/";
this.languageMap = {};
this.scopeToLangMap = {};
this._onigLibPromise = onigLibPromise;
this._onigLibName = onigLibName;
}
get onigLib() {
return this._onigLibPromise;
}
getOnigLibName() {
return this._onigLibName;
}
getLangRegistration(langIdOrAlias) {
return this.languageMap[langIdOrAlias];
}
async loadGrammar(scopeName) {
const lang = this.scopeToLangMap[scopeName];
if (!lang) {
return null;
}
if (lang.grammar) {
return lang.grammar;
}
const g = await fetchGrammar(
languages.includes(lang) ? `${this.languagesPath}${lang.path}` : lang.path
);
lang.grammar = g;
return g;
}
addLanguage(l) {
this.languageMap[l.id] = l;
if (l.aliases) {
l.aliases.forEach((a) => {
this.languageMap[a] = l;
});
}
this.scopeToLangMap[l.scopeName] = l;
}
}
function tokenizeWithTheme(theme, colorMap, fileContents, grammar, options) {
let lines = fileContents.split(/\r\n|\r|\n/);
let ruleStack = vscodeTextmate.INITIAL;
let actual = [];
let final = [];
for (let i = 0, len = lines.length; i < len; i++) {
let line = lines[i];
if (line === "") {
actual = [];
final.push([]);
continue;
}
let resultWithScopes;
let tokensWithScopes;
let tokensWithScopesIndex;
if (options.includeExplanation) {
resultWithScopes = grammar.tokenizeLine(line, ruleStack);
tokensWithScopes = resultWithScopes.tokens;
tokensWithScopesIndex = 0;
}
let result = grammar.tokenizeLine2(line, ruleStack);
let tokensLength = result.tokens.length / 2;
for (let j = 0; j < tokensLength; j++) {
let startIndex = result.tokens[2 * j];
let nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;
if (startIndex === nextStartIndex) {
continue;
}
let metadata = result.tokens[2 * j + 1];
let foreground = StackElementMetadata.getForeground(metadata);
let foregroundColor = colorMap[foreground];
let fontStyle = StackElementMetadata.getFontStyle(metadata);
let explanation = [];
if (options.includeExplanation) {
let offset = 0;
while (startIndex + offset < nextStartIndex) {
let tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];
let tokenWithScopesText = line.substring(
tokenWithScopes.startIndex,
tokenWithScopes.endIndex
);
offset += tokenWithScopesText.length;
explanation.push({
content: tokenWithScopesText,
scopes: explainThemeScopes(theme, tokenWithScopes.scopes)
});
tokensWithScopesIndex++;
}
}
actual.push({
content: line.substring(startIndex, nextStartIndex),
color: foregroundColor,
fontStyle,
explanation
});
}
final.push(actual);
actual = [];
ruleStack = result.ruleStack;
}
return final;
}
function explainThemeScopes(theme, scopes) {
let result = [];
for (let i = 0, len = scopes.length; i < len; i++) {
let parentScopes = scopes.slice(0, i);
let scope = scopes[i];
result[i] = {
scopeName: scope,
themeMatches: explainThemeScope(theme, scope, parentScopes)
};
}
return result;
}
function matchesOne(selector, scope) {
let selectorPrefix = selector + ".";
if (selector === scope || scope.substring(0, selectorPrefix.length) === selectorPrefix) {
return true;
}
return false;
}
function matches(selector, selectorParentScopes, scope, parentScopes) {
if (!matchesOne(selector, scope)) {
return false;
}
let selectorParentIndex = selectorParentScopes.length - 1;
let parentIndex = parentScopes.length - 1;
while (selectorParentIndex >= 0 && parentIndex >= 0) {
if (matchesOne(selectorParentScopes[selectorParentIndex], parentScopes[parentIndex])) {
selectorParentIndex--;
}
parentIndex--;
}
if (selectorParentIndex === -1) {
return true;
}
return false;
}
function explainThemeScope(theme, scope, parentScopes) {
let result = [], resultLen = 0;
for (let i = 0, len = theme.settings.length; i < len; i++) {
let setting = theme.settings[i];
let selectors;
if (typeof setting.scope === "string") {
selectors = setting.scope.split(/,/).map((scope2) => scope2.trim());
} else if (Array.isArray(setting.scope)) {
selectors = setting.scope;
} else {
continue;
}
for (let j = 0, lenJ = selectors.length; j < lenJ; j++) {
let rawSelector = selectors[j];
let rawSelectorPieces = rawSelector.split(/ /);
let selector = rawSelectorPieces[rawSelectorPieces.length - 1];
let selectorParentScopes = rawSelectorPieces.slice(0, rawSelectorPieces.length - 1);
if (matches(selector, selectorParentScopes, scope, parentScopes)) {
result[resultLen++] = setting;
j = lenJ;
}
}
}
return result;
}
// src/colors.ts
var namedColors = [
"black",
"red",
"green",
"yellow",
"blue",
"magenta",
"cyan",
"white",
"brightBlack",
"brightRed",
"brightGreen",
"brightYellow",
"brightBlue",
"brightMagenta",
"brightCyan",
"brightWhite"
];
// src/decorations.ts
var decorations = {
1: "bold",
2: "dim",
3: "italic",
4: "underline",
7: "reverse",
9: "strikethrough"
};
// src/parser.ts
function findSequence(value, position) {
const nextEscape = value.indexOf("\x1B", position);
if (nextEscape !== -1) {
if (value[nextEscape + 1] === "[") {
const nextClose = value.indexOf("m", nextEscape);
return {
sequence: value.substring(nextEscape + 2, nextClose).split(";"),
startPosition: nextEscape,
position: nextClose + 1
};
}
}
return {
position: value.length
};
}
function parseColor(sequence) {
const colorMode = sequence.shift();
if (colorMode === "2") {
const rgb = sequence.splice(0, 3).map((x) => Number.parseInt(x));
if (rgb.length !== 3 || rgb.some((x) => Number.isNaN(x)))
return;
return {
type: "rgb",
rgb
};
} else if (colorMode === "5") {
const index = sequence.shift();
if (index) {
return { type: "table", index: Number(index) };
}
}
}
function parseSequence(sequence) {
const commands = [];
while (sequence.length > 0) {
const code = sequence.shift();
if (!code)
continue;
const codeInt = Number.parseInt(code);
if (Number.isNaN(codeInt))
continue;
if (codeInt === 0) {
commands.push({ type: "resetAll" });
} else if (codeInt <= 9) {
const decoration = decorations[codeInt];
if (decoration) {
commands.push({
type: "setDecoration",
value: decorations[codeInt]
});
}
} else if (codeInt <= 29) {
const decoration = decorations[codeInt - 20];
if (decoration) {
commands.push({
type: "resetDecoration",
value: decoration
});
}
} else if (codeInt <= 37) {
commands.push({
type: "setForegroundColor",
value: { type: "named", name: namedColors[codeInt - 30] }
});
} else if (codeInt === 38) {
const color = parseColor(sequence);
if (color) {
commands.push({
type: "setForegroundColor",
value: color
});
}
} else if (codeInt === 39) {
commands.push({
type: "resetForegroundColor"
});
} else if (codeInt <= 47) {
commands.push({
type: "setBackgroundColor",
value: { type: "named", name: namedColors[codeInt - 40] }
});
} else if (codeInt === 48) {
const color = parseColor(sequence);
if (color) {
commands.push({
type: "setBackgroundColor",
value: color
});
}
} else if (codeInt === 49) {
commands.push({
type: "resetBackgroundColor"
});
} else if (codeInt >= 90 && codeInt <= 97) {
commands.push({
type: "setForegroundColor",
value: { type: "named", name: namedColors[codeInt - 90 + 8] }
});
} else if (codeInt >= 100 && codeInt <= 107) {
commands.push({
type: "setBackgroundColor",
value: { type: "named", name: namedColors[codeInt - 100 + 8] }
});
}
}
return commands;
}
function createAnsiSequenceParser() {
let foreground = null;
let background = null;
let decorations2 = /* @__PURE__ */ new Set();
return {
parse(value) {
const tokens = [];
let position = 0;
do {
const findResult = findSequence(value, position);
const text = findResult.sequence ? value.substring(position, findResult.startPosition) : value.substring(position);
if (text.length > 0) {
tokens.push({
value: text,
foreground,
background,
decorations: new Set(decorations2)
});
}
if (findResult.sequence) {
const commands = parseSequence(findResult.sequence);
for (const styleToken of commands) {
if (styleToken.type === "resetAll") {
foreground = null;
background = null;
decorations2.clear();
} else if (styleToken.type === "resetForegroundColor") {
foreground = null;
} else if (styleToken.type === "resetBackgroundColor") {
background = null;
} else if (styleToken.type === "resetDecoration") {
decorations2.delete(styleToken.value);
}
}
for (const styleToken of commands) {
if (styleToken.type === "setForegroundColor") {
foreground = styleToken.value;
} else if (styleToken.type === "setBackgroundColor") {
background = styleToken.value;
} else if (styleToken.type === "setDecoration") {
decorations2.add(styleToken.value);
}
}
}
position = findResult.position;
} while (position < value.length);
return tokens;
}
};
}
// src/palette.ts
var defaultNamedColorsMap = {
black: "#000000",
red: "#bb0000",
green: "#00bb00",
yellow: "#bbbb00",
blue: "#0000bb",
magenta: "#ff00ff",
cyan: "#00bbbb",
white: "#eeeeee",
brightBlack: "#555555",
brightRed: "#ff5555",
brightGreen: "#00ff00",
brightYellow: "#ffff55",
brightBlue: "#5555ff",
brightMagenta: "#ff55ff",
brightCyan: "#55ffff",
brightWhite: "#ffffff"
};
function createColorPalette(namedColorsMap = defaultNamedColorsMap) {
function namedColor(name) {
return namedColorsMap[name];
}
function rgbColor(rgb) {
return `#${rgb.map((x) => Math.max(0, Math.min(x, 255)).toString(16).padStart(2, "0")).join("")}`;
}
let colorTable;
function getColorTable() {
if (colorTable) {
return colorTable;
}
colorTable = [];
for (let i = 0; i < namedColors.length; i++) {
colorTable.push(namedColor(namedColors[i]));
}
let levels = [0, 95, 135, 175, 215, 255];
for (let r = 0; r < 6; r++) {
for (let g = 0; g < 6; g++) {
for (let b = 0; b < 6; b++) {
colorTable.push(rgbColor([levels[r], levels[g], levels[b]]));
}
}
}
let level = 8;
for (let i = 0; i < 24; i++, level += 10) {
colorTable.push(rgbColor([level, level, level]));
}
return colorTable;
}
function tableColor(index) {
return getColorTable()[index];
}
function value(color) {
switch (color.type) {
case "named":
return namedColor(color.name);
case "rgb":
return rgbColor(color.rgb);
case "table":
return tableColor(color.index);
}
}
return {
value
};
}
function tokenizeAnsiWithTheme(theme, fileContents) {
const lines = fileContents.split(/\r?\n/);
const colorPalette = createColorPalette(
Object.fromEntries(
namedColors.map((name) => [
name,
theme.colors[`terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`]
])
)
);
const parser = createAnsiSequenceParser();
return lines.map(
(line) => parser.parse(line).map((token) => {
let color;
if (token.decorations.has("reverse")) {
color = token.background ? colorPalette.value(token.background) : theme.bg;
} else {
color = token.foreground ? colorPalette.value(token.foreground) : theme.fg;
}
if (token.decorations.has("dim")) {
color = dimColor(color);
}
let fontStyle = FontStyle.None;
if (token.decorations.has("bold")) {
fontStyle |= FontStyle.Bold;
}
if (token.decorations.has("italic")) {
fontStyle |= FontStyle.Italic;
}
if (token.decorations.has("underline")) {
fontStyle |= FontStyle.Underline;
}
return {
content: token.value,
color,
fontStyle
};
})
);
}
function dimColor(color) {
const hexMatch = color.match(/#([0-9a-f]{3})([0-9a-f]{3})?([0-9a-f]{2})?/);
if (hexMatch) {
if (hexMatch[3]) {
const alpha = Math.round(Number.parseInt(hexMatch[3], 16) / 2).toString(16).padStart(2, "0");
return `#${hexMatch[1]}${hexMatch[2]}${alpha}`;
} else if (hexMatch[2]) {
return `#${hexMatch[1]}${hexMatch[2]}80`;
} else {
return `#${Array.from(hexMatch[1]).map((x) => `${x}${x}`).join("")}80`;
}
}
const cssVarMatch = color.match(/var\((--shiki-color-ansi-[\w-]+)\)/);
if (cssVarMatch) {
return `var(${cssVarMatch[1]}-dim)`;
}
return color;
}
const defaultElements = {
pre({ className, style, children }) {
return `${children}`;
},
code({ children }) {
return `${children}`;
},
line({ className, children }) {
return `${children}`;
},
token({ style, children }) {
return `${children}`;
}
};
function renderToHtml(lines, options = {}) {
const bg = options.bg || "#fff";
const optionsByLineNumber = groupBy(options.lineOptions ?? [], (option) => option.line);
const userElements = options.elements || {};
function h(type = "", props = {}, children) {
const element = userElements[type] || defaultElements[type];
if (element) {
children = children.filter(Boolean);
return element({
...props,
children: type === "code" ? children.join("\n") : children.join("")
});
}
return "";
}
return h(
"pre",
{ className: "shiki " + (options.themeName || ""), style: `background-color: ${bg}` },
[
options.langId ? `${options.langId}
` : "",
h(
"code",
{},
lines.map((line, index) => {
const lineNumber = index + 1;
const lineOptions = optionsByLineNumber.get(lineNumber) ?? [];
const lineClasses = getLineClasses(lineOptions).join(" ");
return h(
"line",
{
className: lineClasses,
lines,
line,
index
},
line.map((token, index2) => {
const cssDeclarations = [`color: ${token.color || options.fg}`];
if (token.fontStyle & FontStyle.Italic) {
cssDeclarations.push("font-style: italic");
}
if (token.fontStyle & FontStyle.Bold) {
cssDeclarations.push("font-weight: bold");
}
if (token.fontStyle & FontStyle.Underline) {
cssDeclarations.push("text-decoration: underline");
}
return h(
"token",
{
style: cssDeclarations.join("; "),
tokens: line,
token,
index: index2
},
[escapeHtml(token.content)]
);
})
);
})
)
]
);
}
const htmlEscapes = {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'"
};
function escapeHtml(html) {
return html.replace(/[&<>"']/g, (chr) => htmlEscapes[chr]);
}
function getLineClasses(lineOptions) {
const lineClasses = /* @__PURE__ */ new Set(["line"]);
for (const lineOption of lineOptions) {
for (const lineClass of lineOption.classes ?? []) {
lineClasses.add(lineClass);
}
}
return Array.from(lineClasses);
}
class Registry extends vscodeTextmate.Registry {
constructor(_resolver) {
super(_resolver);
this._resolver = _resolver;
this.themesPath = "themes/";
this._resolvedThemes = {};
this._resolvedGrammars = {};
this._langGraph = /* @__PURE__ */ new Map();
this._langMap = languages.reduce((acc, lang) => {
acc[lang.id] = lang;
return acc;
}, {});
}
getTheme(theme) {
if (typeof theme === "string") {
return this._resolvedThemes[theme];
} else {
return theme;
}
}
async loadTheme(theme) {
if (typeof theme === "string") {
if (!this._resolvedThemes[theme]) {
this._resolvedThemes[theme] = await fetchTheme(`${this.themesPath}${theme}.json`);
}
return this._resolvedThemes[theme];
} else {
theme = toShikiTheme(theme);
if (theme.name) {
this._resolvedThemes[theme.name] = theme;
}
return theme;
}
}
async loadThemes(themes) {
return await Promise.all(themes.map((theme) => this.loadTheme(theme)));
}
getLoadedThemes() {
return Object.keys(this._resolvedThemes);
}
getGrammar(name) {
return this._resolvedGrammars[name];
}
async loadLanguage(lang) {
const embeddedLanguages = lang.embeddedLangs?.reduce(async (acc, l, idx) => {
if (!this.getLoadedLanguages().includes(l) && this._resolver.getLangRegistration(l)) {
await this._resolver.loadGrammar(this._resolver.getLangRegistration(l).scopeName);
acc[this._resolver.getLangRegistration(l).scopeName] = idx + 2;
return acc;
}
}, {});
const grammarConfig = {
embeddedLanguages,
balancedBracketSelectors: lang.balancedBracketSelectors || ["*"],
unbalancedBracketSelectors: lang.unbalancedBracketSelectors || []
};
const g = await this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
this._resolvedGrammars[lang.id] = g;
if (lang.aliases) {
lang.aliases.forEach((la) => {
this._resolvedGrammars[la] = g;
});
}
}
async loadLanguages(langs) {
for (const lang of langs) {
this.resolveEmbeddedLanguages(lang);
}
const langsGraphArray = Array.from(this._langGraph.values());
for (const lang of langsGraphArray) {
this._resolver.addLanguage(lang);
}
for (const lang of langsGraphArray) {
await this.loadLanguage(lang);
}
}
getLoadedLanguages() {
return Object.keys(this._resolvedGrammars);
}
resolveEmbeddedLanguages(lang) {
if (!this._langGraph.has(lang.id)) {
this._langGraph.set(lang.id, lang);
}
if (lang.embeddedLangs) {
for (const embeddedLang of lang.embeddedLangs) {
this._langGraph.set(embeddedLang, this._langMap[embeddedLang]);
}
}
}
}
function resolveLang(lang) {
return typeof lang === "string" ? languages.find((l) => l.id === lang || l.aliases?.includes(lang)) : lang;
}
function resolveOptions(options) {
let _languages = languages;
let _themes = options.themes || [];
let _wasmPath = options.paths?.wasm ? options.paths.wasm.endsWith("/") ? options.paths.wasm : options.paths.wasm + "/" : WASM_PATH;
if (options.langs) {
_languages = options.langs.map(resolveLang);
}
if (options.theme) {
_themes.unshift(options.theme);
}
if (!_themes.length) {
_themes = ["nord"];
}
return { _languages, _themes, _wasmPath };
}
function generateDefaultColorReplacements() {
const replacements = {
"#000001": "var(--shiki-color-text)",
"#000002": "var(--shiki-color-background)",
"#000004": "var(--shiki-token-constant)",
"#000005": "var(--shiki-token-string)",
"#000006": "var(--shiki-token-comment)",
"#000007": "var(--shiki-token-keyword)",
"#000008": "var(--shiki-token-parameter)",
"#000009": "var(--shiki-token-function)",
"#000010": "var(--shiki-token-string-expression)",
"#000011": "var(--shiki-token-punctuation)",
"#000012": "var(--shiki-token-link)"
};
for (let i = 0; i < namedColors.length; i++) {
const code = `#A${i.toString().padStart(5, "0")}`;
const colorNameKebab = namedColors[i].replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
replacements[code] = `var(--shiki-color-ansi-${colorNameKebab})`;
}
return replacements;
}
async function getHighlighter(options) {
const { _languages, _themes, _wasmPath } = resolveOptions(options);
const _resolver = new Resolver(getOniguruma(_wasmPath), "vscode-oniguruma");
const _registry = new Registry(_resolver);
if (options.paths?.themes) {
_registry.themesPath = options.paths.themes.endsWith("/") ? options.paths.themes : options.paths.themes + "/";
}
if (options.paths?.languages) {
_resolver.languagesPath = options.paths.languages.endsWith("/") ? options.paths.languages : options.paths.languages + "/";
}
const themes = await _registry.loadThemes(_themes);
const _defaultTheme = themes[0];
let _currentTheme;
await _registry.loadLanguages(_languages);
let COLOR_REPLACEMENTS = generateDefaultColorReplacements();
function setColorReplacements(map) {
COLOR_REPLACEMENTS = map;
}
function fixCssVariablesTheme(theme, colorMap) {
theme.bg = COLOR_REPLACEMENTS[theme.bg] || theme.bg;
theme.fg = COLOR_REPLACEMENTS[theme.fg] || theme.fg;
Object.entries(theme.colors).forEach(([key, value]) => {
theme.colors[key] = COLOR_REPLACEMENTS[value] || value;
});
colorMap.forEach((val, i) => {
colorMap[i] = COLOR_REPLACEMENTS[val] || val;
});
}
function getTheme(theme) {
const _theme = theme ? _registry.getTheme(theme) : _defaultTheme;
if (!_theme) {
throw Error(`No theme registration for ${theme}`);
}
if (!_currentTheme || _currentTheme.name !== _theme.name) {
_registry.setTheme(_theme);
_currentTheme = _theme;
}
const _colorMap = _registry.getColorMap();
if (_theme.type === "css") {
fixCssVariablesTheme(_theme, _colorMap);
}
return { _theme, _colorMap };
}
function getGrammar(lang) {
const _grammar = _registry.getGrammar(lang);
if (!_grammar) {
throw Error(`No language registration for ${lang}`);
}
return { _grammar };
}
function codeToThemedTokens(code, lang = "text", theme, options2 = { includeExplanation: true }) {
if (isPlaintext(lang)) {
const lines = code.split(/\r\n|\r|\n/);
return [...lines.map((line) => [{ content: line }])];
}
const { _grammar } = getGrammar(lang);
const { _theme, _colorMap } = getTheme(theme);
return tokenizeWithTheme(_theme, _colorMap, code, _grammar, options2);
}
function ansiToThemedTokens(ansi, theme) {
const { _theme } = getTheme(theme);
return tokenizeAnsiWithTheme(_theme, ansi);
}
function codeToHtml(code, arg1 = "text", arg2) {
let options2;
if (typeof arg1 === "object") {
options2 = arg1;
} else {
options2 = {
lang: arg1,
theme: arg2
};
}
const tokens = codeToThemedTokens(code, options2.lang, options2.theme, {
includeExplanation: false
});
const { _theme } = getTheme(options2.theme);
return renderToHtml(tokens, {
fg: _theme.fg,
bg: _theme.bg,
lineOptions: options2?.lineOptions,
themeName: _theme.name
});
}
function ansiToHtml(ansi, options2) {
const tokens = ansiToThemedTokens(ansi, options2?.theme);
const { _theme } = getTheme(options2?.theme);
return renderToHtml(tokens, {
fg: _theme.fg,
bg: _theme.bg,
lineOptions: options2?.lineOptions,
themeName: _theme.name
});
}
async function loadTheme(theme) {
await _registry.loadTheme(theme);
}
async function loadLanguage(lang) {
const _lang = resolveLang(lang);
_resolver.addLanguage(_lang);
await _registry.loadLanguage(_lang);
}
function getLoadedThemes() {
return _registry.getLoadedThemes();
}
function getLoadedLanguages() {
return _registry.getLoadedLanguages();
}
function getBackgroundColor(theme) {
const { _theme } = getTheme(theme);
return _theme.bg;
}
function getForegroundColor(theme) {
const { _theme } = getTheme(theme);
return _theme.fg;
}
return {
codeToThemedTokens,
codeToHtml,
ansiToThemedTokens,
ansiToHtml,
getTheme: (theme) => {
return getTheme(theme)._theme;
},
loadTheme,
loadLanguage,
getBackgroundColor,
getForegroundColor,
getLoadedThemes,
getLoadedLanguages,
setColorReplacements
};
}
function isPlaintext(lang) {
return !lang || ["plaintext", "txt", "text"].includes(lang);
}
function setOnigasmWASM(path) {
setWasm(path);
}
exports.BUNDLED_LANGUAGES = languages;
exports.BUNDLED_THEMES = themes;
exports.FontStyle = FontStyle;
exports.getHighlighter = getHighlighter;
exports.loadTheme = fetchTheme;
exports.renderToHtml = renderToHtml;
exports.setCDN = setCDN;
exports.setOnigasmWASM = setOnigasmWASM;
exports.setWasm = setWasm;
exports.toShikiTheme = toShikiTheme;