@atme-lab/ui-kit 0.1.23 → 0.1.24

package/dist/index.esm83.js

@@ -1,1418 +1,1690 @@
 "use client";
-const r = [
-  {
-    id: "abap",
-    name: "ABAP",
-    import: (() => import("./index.esm91.js"))
-  },
-  {
-    id: "actionscript-3",
-    name: "ActionScript",
-    import: (() => import("./index.esm92.js"))
-  },
-  {
-    id: "ada",
-    name: "Ada",
-    import: (() => import("./index.esm93.js"))
-  },
-  {
-    id: "angular-html",
-    name: "Angular HTML",
-    import: (() => import("./index.esm94.js"))
-  },
-  {
-    id: "angular-ts",
-    name: "Angular TypeScript",
-    import: (() => import("./index.esm95.js"))
-  },
-  {
-    id: "apache",
-    name: "Apache Conf",
-    import: (() => import("./index.esm96.js"))
-  },
-  {
-    id: "apex",
-    name: "Apex",
-    import: (() => import("./index.esm97.js"))
-  },
-  {
-    id: "apl",
-    name: "APL",
-    import: (() => import("./index.esm98.js"))
-  },
-  {
-    id: "applescript",
-    name: "AppleScript",
-    import: (() => import("./index.esm99.js"))
-  },
-  {
-    id: "ara",
-    name: "Ara",
-    import: (() => import("./index.esm100.js"))
-  },
-  {
-    id: "asciidoc",
-    name: "AsciiDoc",
-    aliases: [
-      "adoc"
-    ],
-    import: (() => import("./index.esm101.js"))
-  },
-  {
-    id: "asm",
-    name: "Assembly",
-    import: (() => import("./index.esm102.js"))
-  },
-  {
-    id: "astro",
-    name: "Astro",
-    import: (() => import("./index.esm103.js"))
-  },
-  {
-    id: "awk",
-    name: "AWK",
-    import: (() => import("./index.esm104.js"))
-  },
-  {
-    id: "ballerina",
-    name: "Ballerina",
-    import: (() => import("./index.esm105.js"))
-  },
-  {
-    id: "bat",
-    name: "Batch File",
-    aliases: [
-      "batch"
-    ],
-    import: (() => import("./index.esm106.js"))
-  },
-  {
-    id: "beancount",
-    name: "Beancount",
-    import: (() => import("./index.esm107.js"))
-  },
-  {
-    id: "berry",
-    name: "Berry",
-    aliases: [
-      "be"
-    ],
-    import: (() => import("./index.esm108.js"))
-  },
-  {
-    id: "bibtex",
-    name: "BibTeX",
-    import: (() => import("./index.esm109.js"))
-  },
-  {
-    id: "bicep",
-    name: "Bicep",
-    import: (() => import("./index.esm110.js"))
-  },
-  {
-    id: "blade",
-    name: "Blade",
-    import: (() => import("./index.esm111.js"))
-  },
-  {
-    id: "bsl",
-    name: "1C (Enterprise)",
-    aliases: [
-      "1c"
-    ],
-    import: (() => import("./index.esm112.js"))
-  },
-  {
-    id: "c",
-    name: "C",
-    import: (() => import("./index.esm113.js"))
-  },
-  {
-    id: "c3",
-    name: "C3",
-    import: (() => import("./index.esm114.js"))
-  },
-  {
-    id: "cadence",
-    name: "Cadence",
-    aliases: [
-      "cdc"
-    ],
-    import: (() => import("./index.esm115.js"))
-  },
-  {
-    id: "cairo",
-    name: "Cairo",
-    import: (() => import("./index.esm116.js"))
-  },
-  {
-    id: "clarity",
-    name: "Clarity",
-    import: (() => import("./index.esm117.js"))
-  },
-  {
-    id: "clojure",
-    name: "Clojure",
-    aliases: [
-      "clj"
-    ],
-    import: (() => import("./index.esm118.js"))
-  },
-  {
-    id: "cmake",
-    name: "CMake",
-    import: (() => import("./index.esm119.js"))
-  },
-  {
-    id: "cobol",
-    name: "COBOL",
-    import: (() => import("./index.esm120.js"))
-  },
-  {
-    id: "codeowners",
-    name: "CODEOWNERS",
-    import: (() => import("./index.esm121.js"))
-  },
-  {
-    id: "codeql",
-    name: "CodeQL",
-    aliases: [
-      "ql"
-    ],
-    import: (() => import("./index.esm122.js"))
-  },
-  {
-    id: "coffee",
-    name: "CoffeeScript",
-    aliases: [
-      "coffeescript"
-    ],
-    import: (() => import("./index.esm123.js"))
-  },
-  {
-    id: "common-lisp",
-    name: "Common Lisp",
-    aliases: [
-      "lisp"
-    ],
-    import: (() => import("./index.esm124.js"))
-  },
-  {
-    id: "coq",
-    name: "Coq",
-    import: (() => import("./index.esm125.js"))
-  },
-  {
-    id: "cpp",
-    name: "C++",
-    aliases: [
-      "c++"
-    ],
-    import: (() => import("./index.esm126.js"))
-  },
-  {
-    id: "crystal",
-    name: "Crystal",
-    import: (() => import("./index.esm127.js"))
-  },
-  {
-    id: "csharp",
-    name: "C#",
-    aliases: [
-      "c#",
-      "cs"
-    ],
-    import: (() => import("./index.esm128.js"))
-  },
-  {
-    id: "css",
-    name: "CSS",
-    import: (() => import("./index.esm129.js"))
-  },
-  {
-    id: "csv",
-    name: "CSV",
-    import: (() => import("./index.esm130.js"))
-  },
-  {
-    id: "cue",
-    name: "CUE",
-    import: (() => import("./index.esm131.js"))
-  },
-  {
-    id: "cypher",
-    name: "Cypher",
-    aliases: [
-      "cql"
-    ],
-    import: (() => import("./index.esm132.js"))
-  },
-  {
-    id: "d",
-    name: "D",
-    import: (() => import("./index.esm133.js"))
-  },
-  {
-    id: "dart",
-    name: "Dart",
-    import: (() => import("./index.esm134.js"))
-  },
-  {
-    id: "dax",
-    name: "DAX",
-    import: (() => import("./index.esm135.js"))
-  },
-  {
-    id: "desktop",
-    name: "Desktop",
-    import: (() => import("./index.esm136.js"))
-  },
-  {
-    id: "diff",
-    name: "Diff",
-    import: (() => import("./index.esm137.js"))
-  },
-  {
-    id: "docker",
-    name: "Dockerfile",
-    aliases: [
-      "dockerfile"
-    ],
-    import: (() => import("./index.esm138.js"))
-  },
-  {
-    id: "dotenv",
-    name: "dotEnv",
-    import: (() => import("./index.esm139.js"))
-  },
-  {
-    id: "dream-maker",
-    name: "Dream Maker",
-    import: (() => import("./index.esm140.js"))
-  },
-  {
-    id: "edge",
-    name: "Edge",
-    import: (() => import("./index.esm141.js"))
-  },
-  {
-    id: "elixir",
-    name: "Elixir",
-    import: (() => import("./index.esm142.js"))
-  },
-  {
-    id: "elm",
-    name: "Elm",
-    import: (() => import("./index.esm143.js"))
-  },
-  {
-    id: "emacs-lisp",
-    name: "Emacs Lisp",
-    aliases: [
-      "elisp"
-    ],
-    import: (() => import("./index.esm144.js"))
-  },
-  {
-    id: "erb",
-    name: "ERB",
-    import: (() => import("./index.esm145.js"))
-  },
-  {
-    id: "erlang",
-    name: "Erlang",
-    aliases: [
-      "erl"
-    ],
-    import: (() => import("./index.esm146.js"))
-  },
-  {
-    id: "fennel",
-    name: "Fennel",
-    import: (() => import("./index.esm147.js"))
-  },
-  {
-    id: "fish",
-    name: "Fish",
-    import: (() => import("./index.esm148.js"))
-  },
-  {
-    id: "fluent",
-    name: "Fluent",
-    aliases: [
-      "ftl"
-    ],
-    import: (() => import("./index.esm149.js"))
-  },
-  {
-    id: "fortran-fixed-form",
-    name: "Fortran (Fixed Form)",
-    aliases: [
-      "f",
-      "for",
-      "f77"
-    ],
-    import: (() => import("./index.esm150.js"))
-  },
-  {
-    id: "fortran-free-form",
-    name: "Fortran (Free Form)",
-    aliases: [
-      "f90",
-      "f95",
-      "f03",
-      "f08",
-      "f18"
-    ],
-    import: (() => import("./index.esm151.js"))
-  },
-  {
-    id: "fsharp",
-    name: "F#",
-    aliases: [
-      "f#",
-      "fs"
-    ],
-    import: (() => import("./index.esm152.js"))
-  },
-  {
-    id: "gdresource",
-    name: "GDResource",
-    aliases: [
-      "tscn",
-      "tres"
-    ],
-    import: (() => import("./index.esm153.js"))
-  },
-  {
-    id: "gdscript",
-    name: "GDScript",
-    aliases: [
-      "gd"
-    ],
-    import: (() => import("./index.esm154.js"))
-  },
-  {
-    id: "gdshader",
-    name: "GDShader",
-    import: (() => import("./index.esm155.js"))
-  },
-  {
-    id: "genie",
-    name: "Genie",
-    import: (() => import("./index.esm156.js"))
-  },
-  {
-    id: "gherkin",
-    name: "Gherkin",
-    import: (() => import("./index.esm157.js"))
-  },
-  {
-    id: "git-commit",
-    name: "Git Commit Message",
-    import: (() => import("./index.esm158.js"))
-  },
-  {
-    id: "git-rebase",
-    name: "Git Rebase Message",
-    import: (() => import("./index.esm159.js"))
-  },
-  {
-    id: "gleam",
-    name: "Gleam",
-    import: (() => import("./index.esm160.js"))
-  },
-  {
-    id: "glimmer-js",
-    name: "Glimmer JS",
-    aliases: [
-      "gjs"
-    ],
-    import: (() => import("./index.esm161.js"))
-  },
-  {
-    id: "glimmer-ts",
-    name: "Glimmer TS",
-    aliases: [
-      "gts"
-    ],
-    import: (() => import("./index.esm162.js"))
-  },
-  {
-    id: "glsl",
-    name: "GLSL",
-    import: (() => import("./index.esm163.js"))
-  },
-  {
-    id: "gn",
-    name: "GN",
-    import: (() => import("./index.esm164.js"))
-  },
-  {
-    id: "gnuplot",
-    name: "Gnuplot",
-    import: (() => import("./index.esm165.js"))
-  },
-  {
-    id: "go",
-    name: "Go",
-    import: (() => import("./index.esm166.js"))
-  },
-  {
-    id: "graphql",
-    name: "GraphQL",
-    aliases: [
-      "gql"
-    ],
-    import: (() => import("./index.esm167.js"))
-  },
-  {
-    id: "groovy",
-    name: "Groovy",
-    import: (() => import("./index.esm168.js"))
-  },
-  {
-    id: "hack",
-    name: "Hack",
-    import: (() => import("./index.esm169.js"))
-  },
-  {
-    id: "haml",
-    name: "Ruby Haml",
-    import: (() => import("./index.esm170.js"))
-  },
-  {
-    id: "handlebars",
-    name: "Handlebars",
-    aliases: [
-      "hbs"
-    ],
-    import: (() => import("./index.esm171.js"))
-  },
-  {
-    id: "haskell",
-    name: "Haskell",
-    aliases: [
-      "hs"
-    ],
-    import: (() => import("./index.esm172.js"))
-  },
-  {
-    id: "haxe",
-    name: "Haxe",
-    import: (() => import("./index.esm173.js"))
-  },
-  {
-    id: "hcl",
-    name: "HashiCorp HCL",
-    import: (() => import("./index.esm174.js"))
-  },
-  {
-    id: "hjson",
-    name: "Hjson",
-    import: (() => import("./index.esm175.js"))
-  },
-  {
-    id: "hlsl",
-    name: "HLSL",
-    import: (() => import("./index.esm176.js"))
-  },
-  {
-    id: "html",
-    name: "HTML",
-    import: (() => import("./index.esm177.js"))
-  },
-  {
-    id: "html-derivative",
-    name: "HTML (Derivative)",
-    import: (() => import("./index.esm178.js"))
-  },
-  {
-    id: "http",
-    name: "HTTP",
-    import: (() => import("./index.esm179.js"))
-  },
-  {
-    id: "hurl",
-    name: "Hurl",
-    import: (() => import("./index.esm180.js"))
-  },
-  {
-    id: "hxml",
-    name: "HXML",
-    import: (() => import("./index.esm181.js"))
-  },
-  {
-    id: "hy",
-    name: "Hy",
-    import: (() => import("./index.esm182.js"))
-  },
-  {
-    id: "imba",
-    name: "Imba",
-    import: (() => import("./index.esm183.js"))
-  },
-  {
-    id: "ini",
-    name: "INI",
-    aliases: [
-      "properties"
-    ],
-    import: (() => import("./index.esm184.js"))
-  },
-  {
-    id: "java",
-    name: "Java",
-    import: (() => import("./index.esm185.js"))
-  },
-  {
-    id: "javascript",
-    name: "JavaScript",
-    aliases: [
-      "js",
-      "cjs",
-      "mjs"
-    ],
-    import: (() => import("./index.esm186.js"))
-  },
-  {
-    id: "jinja",
-    name: "Jinja",
-    import: (() => import("./index.esm187.js"))
-  },
-  {
-    id: "jison",
-    name: "Jison",
-    import: (() => import("./index.esm188.js"))
-  },
-  {
-    id: "json",
-    name: "JSON",
-    import: (() => import("./index.esm189.js"))
-  },
-  {
-    id: "json5",
-    name: "JSON5",
-    import: (() => import("./index.esm190.js"))
-  },
-  {
-    id: "jsonc",
-    name: "JSON with Comments",
-    import: (() => import("./index.esm191.js"))
-  },
-  {
-    id: "jsonl",
-    name: "JSON Lines",
-    import: (() => import("./index.esm192.js"))
-  },
-  {
-    id: "jsonnet",
-    name: "Jsonnet",
-    import: (() => import("./index.esm193.js"))
-  },
-  {
-    id: "jssm",
-    name: "JSSM",
-    aliases: [
-      "fsl"
-    ],
-    import: (() => import("./index.esm194.js"))
-  },
-  {
-    id: "jsx",
-    name: "JSX",
-    import: (() => import("./index.esm195.js"))
-  },
-  {
-    id: "julia",
-    name: "Julia",
-    aliases: [
-      "jl"
-    ],
-    import: (() => import("./index.esm196.js"))
-  },
-  {
-    id: "kdl",
-    name: "KDL",
-    import: (() => import("./index.esm197.js"))
-  },
-  {
-    id: "kotlin",
-    name: "Kotlin",
-    aliases: [
-      "kt",
-      "kts"
-    ],
-    import: (() => import("./index.esm198.js"))
-  },
-  {
-    id: "kusto",
-    name: "Kusto",
-    aliases: [
-      "kql"
-    ],
-    import: (() => import("./index.esm199.js"))
-  },
-  {
-    id: "latex",
-    name: "LaTeX",
-    import: (() => import("./index.esm200.js"))
-  },
-  {
-    id: "lean",
-    name: "Lean 4",
-    aliases: [
-      "lean4"
-    ],
-    import: (() => import("./index.esm201.js"))
-  },
-  {
-    id: "less",
-    name: "Less",
-    import: (() => import("./index.esm202.js"))
-  },
-  {
-    id: "liquid",
-    name: "Liquid",
-    import: (() => import("./index.esm203.js"))
-  },
-  {
-    id: "llvm",
-    name: "LLVM IR",
-    import: (() => import("./index.esm204.js"))
-  },
-  {
-    id: "log",
-    name: "Log file",
-    import: (() => import("./index.esm205.js"))
-  },
-  {
-    id: "logo",
-    name: "Logo",
-    import: (() => import("./index.esm206.js"))
-  },
-  {
-    id: "lua",
-    name: "Lua",
-    import: (() => import("./index.esm207.js"))
-  },
-  {
-    id: "luau",
-    name: "Luau",
-    import: (() => import("./index.esm208.js"))
-  },
-  {
-    id: "make",
-    name: "Makefile",
-    aliases: [
-      "makefile"
-    ],
-    import: (() => import("./index.esm209.js"))
-  },
-  {
-    id: "markdown",
-    name: "Markdown",
-    aliases: [
-      "md"
-    ],
-    import: (() => import("./index.esm210.js"))
-  },
-  {
-    id: "marko",
-    name: "Marko",
-    import: (() => import("./index.esm211.js"))
-  },
-  {
-    id: "matlab",
-    name: "MATLAB",
-    import: (() => import("./index.esm212.js"))
-  },
-  {
-    id: "mdc",
-    name: "MDC",
-    import: (() => import("./index.esm213.js"))
-  },
-  {
-    id: "mdx",
-    name: "MDX",
-    import: (() => import("./index.esm214.js"))
-  },
-  {
-    id: "mermaid",
-    name: "Mermaid",
-    aliases: [
-      "mmd"
-    ],
-    import: (() => import("./index.esm215.js"))
-  },
-  {
-    id: "mipsasm",
-    name: "MIPS Assembly",
-    aliases: [
-      "mips"
-    ],
-    import: (() => import("./index.esm216.js"))
-  },
-  {
-    id: "mojo",
-    name: "Mojo",
-    import: (() => import("./index.esm217.js"))
-  },
-  {
-    id: "moonbit",
-    name: "MoonBit",
-    aliases: [
-      "mbt",
-      "mbti"
-    ],
-    import: (() => import("./index.esm218.js"))
-  },
-  {
-    id: "move",
-    name: "Move",
-    import: (() => import("./index.esm219.js"))
-  },
-  {
-    id: "narrat",
-    name: "Narrat Language",
-    aliases: [
-      "nar"
-    ],
-    import: (() => import("./index.esm220.js"))
-  },
-  {
-    id: "nextflow",
-    name: "Nextflow",
-    aliases: [
-      "nf"
-    ],
-    import: (() => import("./index.esm221.js"))
-  },
-  {
-    id: "nginx",
-    name: "Nginx",
-    import: (() => import("./index.esm222.js"))
-  },
-  {
-    id: "nim",
-    name: "Nim",
-    import: (() => import("./index.esm223.js"))
-  },
-  {
-    id: "nix",
-    name: "Nix",
-    import: (() => import("./index.esm224.js"))
-  },
-  {
-    id: "nushell",
-    name: "nushell",
-    aliases: [
-      "nu"
-    ],
-    import: (() => import("./index.esm225.js"))
-  },
-  {
-    id: "objective-c",
-    name: "Objective-C",
-    aliases: [
-      "objc"
-    ],
-    import: (() => import("./index.esm226.js"))
-  },
-  {
-    id: "objective-cpp",
-    name: "Objective-C++",
-    import: (() => import("./index.esm227.js"))
-  },
-  {
-    id: "ocaml",
-    name: "OCaml",
-    import: (() => import("./index.esm228.js"))
-  },
-  {
-    id: "odin",
-    name: "Odin",
-    import: (() => import("./index.esm229.js"))
-  },
-  {
-    id: "openscad",
-    name: "OpenSCAD",
-    aliases: [
-      "scad"
-    ],
-    import: (() => import("./index.esm230.js"))
-  },
-  {
-    id: "pascal",
-    name: "Pascal",
-    import: (() => import("./index.esm231.js"))
-  },
-  {
-    id: "perl",
-    name: "Perl",
-    import: (() => import("./index.esm232.js"))
-  },
-  {
-    id: "php",
-    name: "PHP",
-    import: (() => import("./index.esm233.js"))
-  },
-  {
-    id: "pkl",
-    name: "Pkl",
-    import: (() => import("./index.esm234.js"))
-  },
-  {
-    id: "plsql",
-    name: "PL/SQL",
-    import: (() => import("./index.esm235.js"))
-  },
-  {
-    id: "po",
-    name: "Gettext PO",
-    aliases: [
-      "pot",
-      "potx"
-    ],
-    import: (() => import("./index.esm236.js"))
-  },
-  {
-    id: "polar",
-    name: "Polar",
-    import: (() => import("./index.esm237.js"))
-  },
-  {
-    id: "postcss",
-    name: "PostCSS",
-    import: (() => import("./index.esm238.js"))
-  },
-  {
-    id: "powerquery",
-    name: "PowerQuery",
-    import: (() => import("./index.esm239.js"))
-  },
-  {
-    id: "powershell",
-    name: "PowerShell",
-    aliases: [
-      "ps",
-      "ps1"
-    ],
-    import: (() => import("./index.esm240.js"))
-  },
-  {
-    id: "prisma",
-    name: "Prisma",
-    import: (() => import("./index.esm241.js"))
-  },
-  {
-    id: "prolog",
-    name: "Prolog",
-    import: (() => import("./index.esm242.js"))
-  },
-  {
-    id: "proto",
-    name: "Protocol Buffer 3",
-    aliases: [
-      "protobuf"
-    ],
-    import: (() => import("./index.esm243.js"))
-  },
-  {
-    id: "pug",
-    name: "Pug",
-    aliases: [
-      "jade"
-    ],
-    import: (() => import("./index.esm244.js"))
-  },
-  {
-    id: "puppet",
-    name: "Puppet",
-    import: (() => import("./index.esm245.js"))
-  },
-  {
-    id: "purescript",
-    name: "PureScript",
-    import: (() => import("./index.esm246.js"))
-  },
-  {
-    id: "python",
-    name: "Python",
-    aliases: [
-      "py"
-    ],
-    import: (() => import("./index.esm247.js"))
-  },
-  {
-    id: "qml",
-    name: "QML",
-    import: (() => import("./index.esm248.js"))
-  },
-  {
-    id: "qmldir",
-    name: "QML Directory",
-    import: (() => import("./index.esm249.js"))
-  },
-  {
-    id: "qss",
-    name: "Qt Style Sheets",
-    import: (() => import("./index.esm250.js"))
-  },
-  {
-    id: "r",
-    name: "R",
-    import: (() => import("./index.esm251.js"))
-  },
-  {
-    id: "racket",
-    name: "Racket",
-    import: (() => import("./index.esm252.js"))
-  },
-  {
-    id: "raku",
-    name: "Raku",
-    aliases: [
-      "perl6"
-    ],
-    import: (() => import("./index.esm253.js"))
-  },
-  {
-    id: "razor",
-    name: "ASP.NET Razor",
-    import: (() => import("./index.esm254.js"))
-  },
-  {
-    id: "reg",
-    name: "Windows Registry Script",
-    import: (() => import("./index.esm255.js"))
-  },
-  {
-    id: "regexp",
-    name: "RegExp",
-    aliases: [
-      "regex"
-    ],
-    import: (() => import("./index.esm256.js"))
-  },
-  {
-    id: "rel",
-    name: "Rel",
-    import: (() => import("./index.esm257.js"))
-  },
-  {
-    id: "riscv",
-    name: "RISC-V",
-    import: (() => import("./index.esm258.js"))
-  },
-  {
-    id: "ron",
-    name: "RON",
-    import: (() => import("./index.esm259.js"))
-  },
-  {
-    id: "rosmsg",
-    name: "ROS Interface",
-    import: (() => import("./index.esm260.js"))
-  },
-  {
-    id: "rst",
-    name: "reStructuredText",
-    import: (() => import("./index.esm261.js"))
-  },
-  {
-    id: "ruby",
-    name: "Ruby",
-    aliases: [
-      "rb"
-    ],
-    import: (() => import("./index.esm262.js"))
-  },
-  {
-    id: "rust",
-    name: "Rust",
-    aliases: [
-      "rs"
-    ],
-    import: (() => import("./index.esm263.js"))
-  },
-  {
-    id: "sas",
-    name: "SAS",
-    import: (() => import("./index.esm264.js"))
-  },
-  {
-    id: "sass",
-    name: "Sass",
-    import: (() => import("./index.esm265.js"))
-  },
-  {
-    id: "scala",
-    name: "Scala",
-    import: (() => import("./index.esm266.js"))
-  },
-  {
-    id: "scheme",
-    name: "Scheme",
-    import: (() => import("./index.esm267.js"))
-  },
-  {
-    id: "scss",
-    name: "SCSS",
-    import: (() => import("./index.esm268.js"))
-  },
-  {
-    id: "sdbl",
-    name: "1C (Query)",
-    aliases: [
-      "1c-query"
-    ],
-    import: (() => import("./index.esm269.js"))
-  },
-  {
-    id: "shaderlab",
-    name: "ShaderLab",
-    aliases: [
-      "shader"
-    ],
-    import: (() => import("./index.esm270.js"))
-  },
-  {
-    id: "shellscript",
-    name: "Shell",
-    aliases: [
-      "bash",
-      "sh",
-      "shell",
-      "zsh"
-    ],
-    import: (() => import("./index.esm271.js"))
-  },
-  {
-    id: "shellsession",
-    name: "Shell Session",
-    aliases: [
-      "console"
-    ],
-    import: (() => import("./index.esm272.js"))
-  },
-  {
-    id: "smalltalk",
-    name: "Smalltalk",
-    import: (() => import("./index.esm273.js"))
-  },
-  {
-    id: "solidity",
-    name: "Solidity",
-    import: (() => import("./index.esm274.js"))
-  },
-  {
-    id: "soy",
-    name: "Closure Templates",
-    aliases: [
-      "closure-templates"
-    ],
-    import: (() => import("./index.esm275.js"))
-  },
-  {
-    id: "sparql",
-    name: "SPARQL",
-    import: (() => import("./index.esm276.js"))
-  },
-  {
-    id: "splunk",
-    name: "Splunk Query Language",
-    aliases: [
-      "spl"
-    ],
-    import: (() => import("./index.esm277.js"))
-  },
-  {
-    id: "sql",
-    name: "SQL",
-    import: (() => import("./index.esm278.js"))
-  },
-  {
-    id: "ssh-config",
-    name: "SSH Config",
-    import: (() => import("./index.esm279.js"))
-  },
-  {
-    id: "stata",
-    name: "Stata",
-    import: (() => import("./index.esm280.js"))
-  },
-  {
-    id: "stylus",
-    name: "Stylus",
-    aliases: [
-      "styl"
-    ],
-    import: (() => import("./index.esm281.js"))
-  },
-  {
-    id: "surrealql",
-    name: "SurrealQL",
-    aliases: [
-      "surql"
-    ],
-    import: (() => import("./index.esm282.js"))
-  },
-  {
-    id: "svelte",
-    name: "Svelte",
-    import: (() => import("./index.esm283.js"))
-  },
-  {
-    id: "swift",
-    name: "Swift",
-    import: (() => import("./index.esm284.js"))
-  },
-  {
-    id: "system-verilog",
-    name: "SystemVerilog",
-    import: (() => import("./index.esm285.js"))
-  },
-  {
-    id: "systemd",
-    name: "Systemd Units",
-    import: (() => import("./index.esm286.js"))
-  },
-  {
-    id: "talonscript",
-    name: "TalonScript",
-    aliases: [
-      "talon"
-    ],
-    import: (() => import("./index.esm287.js"))
-  },
-  {
-    id: "tasl",
-    name: "Tasl",
-    import: (() => import("./index.esm288.js"))
-  },
-  {
-    id: "tcl",
-    name: "Tcl",
-    import: (() => import("./index.esm289.js"))
-  },
-  {
-    id: "templ",
-    name: "Templ",
-    import: (() => import("./index.esm290.js"))
-  },
-  {
-    id: "terraform",
-    name: "Terraform",
-    aliases: [
-      "tf",
-      "tfvars"
-    ],
-    import: (() => import("./index.esm291.js"))
-  },
-  {
-    id: "tex",
-    name: "TeX",
-    import: (() => import("./index.esm292.js"))
-  },
-  {
-    id: "toml",
-    name: "TOML",
-    import: (() => import("./index.esm293.js"))
-  },
-  {
-    id: "ts-tags",
-    name: "TypeScript with Tags",
-    aliases: [
-      "lit"
-    ],
-    import: (() => import("./index.esm294.js"))
-  },
-  {
-    id: "tsv",
-    name: "TSV",
-    import: (() => import("./index.esm295.js"))
-  },
-  {
-    id: "tsx",
-    name: "TSX",
-    import: (() => import("./index.esm296.js"))
-  },
-  {
-    id: "turtle",
-    name: "Turtle",
-    import: (() => import("./index.esm297.js"))
-  },
-  {
-    id: "twig",
-    name: "Twig",
-    import: (() => import("./index.esm298.js"))
-  },
-  {
-    id: "typescript",
-    name: "TypeScript",
-    aliases: [
-      "ts",
-      "cts",
-      "mts"
-    ],
-    import: (() => import("./index.esm299.js"))
-  },
-  {
-    id: "typespec",
-    name: "TypeSpec",
-    aliases: [
-      "tsp"
-    ],
-    import: (() => import("./index.esm300.js"))
-  },
-  {
-    id: "typst",
-    name: "Typst",
-    aliases: [
-      "typ"
-    ],
-    import: (() => import("./index.esm301.js"))
-  },
-  {
-    id: "v",
-    name: "V",
-    import: (() => import("./index.esm302.js"))
-  },
-  {
-    id: "vala",
-    name: "Vala",
-    import: (() => import("./index.esm303.js"))
-  },
-  {
-    id: "vb",
-    name: "Visual Basic",
-    aliases: [
-      "cmd"
-    ],
-    import: (() => import("./index.esm304.js"))
-  },
-  {
-    id: "verilog",
-    name: "Verilog",
-    import: (() => import("./index.esm305.js"))
-  },
-  {
-    id: "vhdl",
-    name: "VHDL",
-    import: (() => import("./index.esm306.js"))
-  },
-  {
-    id: "viml",
-    name: "Vim Script",
-    aliases: [
-      "vim",
-      "vimscript"
-    ],
-    import: (() => import("./index.esm307.js"))
-  },
-  {
-    id: "vue",
-    name: "Vue",
-    import: (() => import("./index.esm308.js"))
-  },
-  {
-    id: "vue-html",
-    name: "Vue HTML",
-    import: (() => import("./index.esm309.js"))
-  },
-  {
-    id: "vue-vine",
-    name: "Vue Vine",
-    import: (() => import("./index.esm310.js"))
-  },
-  {
-    id: "vyper",
-    name: "Vyper",
-    aliases: [
-      "vy"
-    ],
-    import: (() => import("./index.esm311.js"))
-  },
-  {
-    id: "wasm",
-    name: "WebAssembly",
-    import: (() => import("./index.esm312.js"))
-  },
-  {
-    id: "wenyan",
-    name: "Wenyan",
-    aliases: [
-      "文言"
-    ],
-    import: (() => import("./index.esm313.js"))
-  },
-  {
-    id: "wgsl",
-    name: "WGSL",
-    import: (() => import("./index.esm314.js"))
-  },
-  {
-    id: "wikitext",
-    name: "Wikitext",
-    aliases: [
-      "mediawiki",
-      "wiki"
-    ],
-    import: (() => import("./index.esm315.js"))
-  },
-  {
-    id: "wit",
-    name: "WebAssembly Interface Types",
-    import: (() => import("./index.esm316.js"))
-  },
-  {
-    id: "wolfram",
-    name: "Wolfram",
-    aliases: [
-      "wl"
-    ],
-    import: (() => import("./index.esm317.js"))
-  },
-  {
-    id: "xml",
-    name: "XML",
-    import: (() => import("./index.esm318.js"))
-  },
-  {
-    id: "xsl",
-    name: "XSL",
-    import: (() => import("./index.esm319.js"))
-  },
-  {
-    id: "yaml",
-    name: "YAML",
-    aliases: [
-      "yml"
-    ],
-    import: (() => import("./index.esm320.js"))
-  },
-  {
-    id: "zenscript",
-    name: "ZenScript",
-    import: (() => import("./index.esm321.js"))
-  },
-  {
-    id: "zig",
-    name: "Zig",
-    import: (() => import("./index.esm322.js"))
-  }
-], o = Object.fromEntries(r.map((i) => [i.id, i.import])), a = Object.fromEntries(r.flatMap((i) => {
-  var m;
-  return ((m = i.aliases) == null ? void 0 : m.map((t) => [t, i.import])) || [];
-})), e = {
-  ...o,
-  ...a
+var we = Object.defineProperty;
+var ke = (n, t, e) => t in n ? we(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var v = (n, t, e) => ke(n, typeof t != "symbol" ? t + "" : t, e);
+import { ShikiError as k } from "./index.esm86.js";
+import { FontStyle as L, INITIAL as U, EncodedTokenMetadata as re, Registry as _e, Theme as Le } from "./index.esm89.js";
+import { toHtml as ve } from "./index.esm90.js";
+function D(n, t) {
+  const e = typeof n == "string" ? {} : { ...n.colorReplacements }, s = typeof n == "string" ? n : n.name;
+  for (const [r, o] of Object.entries((t == null ? void 0 : t.colorReplacements) || {}))
+    typeof o == "string" ? e[r] = o : r === s && Object.assign(e, o);
+  return e;
+}
+function E(n, t) {
+  return n && ((t == null ? void 0 : t[n == null ? void 0 : n.toLowerCase()]) || n);
+}
+function Ce(n) {
+  return Array.isArray(n) ? n : [n];
+}
+async function he(n) {
+  return Promise.resolve(typeof n == "function" ? n() : n).then((t) => t.default || t);
+}
+function Q(n) {
+  return !n || ["plaintext", "txt", "text", "plain"].includes(n);
+}
+function ue(n) {
+  return n === "ansi" || Q(n);
+}
+function X(n) {
+  return n === "none";
+}
+function ge(n) {
+  return X(n);
+}
+function de(n, t) {
+  var s;
+  if (!t)
+    return n;
+  n.properties || (n.properties = {}), (s = n.properties).class || (s.class = []), typeof n.properties.class == "string" && (n.properties.class = n.properties.class.split(/\s+/g)), Array.isArray(n.properties.class) || (n.properties.class = []);
+  const e = Array.isArray(t) ? t : t.split(/\s+/g);
+  for (const r of e)
+    r && !n.properties.class.includes(r) && n.properties.class.push(r);
+  return n;
+}
+function V(n, t = !1) {
+  var o;
+  if (n.length === 0)
+    return [["", 0]];
+  const e = n.split(/(\r?\n)/g);
+  let s = 0;
+  const r = [];
+  for (let a = 0; a < e.length; a += 2) {
+    const i = t ? e[a] + (e[a + 1] || "") : e[a];
+    r.push([i, s]), s += e[a].length, s += ((o = e[a + 1]) == null ? void 0 : o.length) || 0;
+  }
+  return r;
+}
+function xe(n) {
+  const t = V(n, !0).map(([r]) => r);
+  function e(r) {
+    if (r === n.length)
+      return {
+        line: t.length - 1,
+        character: t[t.length - 1].length
+      };
+    let o = r, a = 0;
+    for (const i of t) {
+      if (o < i.length)
+        break;
+      o -= i.length, a++;
+    }
+    return { line: a, character: o };
+  }
+  function s(r, o) {
+    let a = 0;
+    for (let i = 0; i < r; i++)
+      a += t[i].length;
+    return a += o, a;
+  }
+  return {
+    lines: t,
+    indexToPos: e,
+    posToIndex: s
+  };
+}
+function yt(n, t, e) {
+  const s = /* @__PURE__ */ new Set();
+  for (const o of n.matchAll(/:?lang=["']([^"']+)["']/g)) {
+    const a = o[1].toLowerCase().trim();
+    a && s.add(a);
+  }
+  for (const o of n.matchAll(/(?:```|~~~)([\w-]+)/g)) {
+    const a = o[1].toLowerCase().trim();
+    a && s.add(a);
+  }
+  for (const o of n.matchAll(/\\begin\{([\w-]+)\}/g)) {
+    const a = o[1].toLowerCase().trim();
+    a && s.add(a);
+  }
+  for (const o of n.matchAll(/<script\s+(?:type|lang)=["']([^"']+)["']/gi)) {
+    const a = o[1].toLowerCase().trim(), i = a.includes("/") ? a.split("/").pop() : a;
+    i && s.add(i);
+  }
+  if (!e)
+    return Array.from(s);
+  const r = e.getBundledLanguages();
+  return Array.from(s).filter((o) => o && r[o]);
+}
+const Z = "light-dark()", $e = ["color", "background-color"];
+function Ne(n, t) {
+  let e = 0;
+  const s = [];
+  for (const r of t)
+    r > e && s.push({
+      ...n,
+      content: n.content.slice(e, r),
+      offset: n.offset + e
+    }), e = r;
+  return e < n.content.length && s.push({
+    ...n,
+    content: n.content.slice(e),
+    offset: n.offset + e
+  }), s;
+}
+function Ie(n, t) {
+  const e = Array.from(t instanceof Set ? t : new Set(t)).sort((s, r) => s - r);
+  return e.length ? n.map((s) => s.flatMap((r) => {
+    const o = e.filter((a) => r.offset < a && a < r.offset + r.content.length).map((a) => a - r.offset).sort((a, i) => a - i);
+    return o.length ? Ne(r, o) : r;
+  })) : n;
+}
+function Ee(n, t, e, s, r = "css-vars") {
+  const o = {
+    content: n.content,
+    explanation: n.explanation,
+    offset: n.offset
+  }, a = t.map((u) => W(n.variants[u])), i = new Set(a.flatMap((u) => Object.keys(u))), l = {}, c = (u, f) => {
+    const h = f === "color" ? "" : f === "background-color" ? "-bg" : `-${f}`;
+    return e + t[u] + (f === "color" ? "" : h);
+  };
+  return a.forEach((u, f) => {
+    for (const h of i) {
+      const d = u[h] || "inherit";
+      if (f === 0 && s && $e.includes(h))
+        if (s === Z && a.length > 1) {
+          const m = t.findIndex((b) => b === "light"), y = t.findIndex((b) => b === "dark");
+          if (m === -1 || y === -1)
+            throw new k('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
+          const T = a[m][h] || "inherit", p = a[y][h] || "inherit";
+          l[h] = `light-dark(${T}, ${p})`, r === "css-vars" && (l[c(f, h)] = d);
+        } else
+          l[h] = d;
+      else
+        r === "css-vars" && (l[c(f, h)] = d);
+    }
+  }), o.htmlStyle = l, o;
+}
+function W(n) {
+  const t = {};
+  if (n.color && (t.color = n.color), n.bgColor && (t["background-color"] = n.bgColor), n.fontStyle) {
+    n.fontStyle & L.Italic && (t["font-style"] = "italic"), n.fontStyle & L.Bold && (t["font-weight"] = "bold");
+    const e = [];
+    n.fontStyle & L.Underline && e.push("underline"), n.fontStyle & L.Strikethrough && e.push("line-through"), e.length && (t["text-decoration"] = e.join(" "));
+  }
+  return t;
+}
+function q(n) {
+  return typeof n == "string" ? n : Object.entries(n).map(([t, e]) => `${t}:${e}`).join(";");
+}
+const me = /* @__PURE__ */ new WeakMap();
+function J(n, t) {
+  me.set(n, t);
+}
+function R(n) {
+  return me.get(n);
+}
+class F {
+  constructor(...t) {
+    /**
+     * Theme to Stack mapping
+     */
+    v(this, "_stacks", {});
+    v(this, "lang");
+    if (t.length === 2) {
+      const [e, s] = t;
+      this.lang = s, this._stacks = e;
+    } else {
+      const [e, s, r] = t;
+      this.lang = s, this._stacks = { [r]: e };
+    }
+  }
+  get themes() {
+    return Object.keys(this._stacks);
+  }
+  get theme() {
+    return this.themes[0];
+  }
+  get _stack() {
+    return this._stacks[this.theme];
+  }
+  /**
+   * Static method to create a initial grammar state.
+   */
+  static initial(t, e) {
+    return new F(
+      Object.fromEntries(Ce(e).map((s) => [s, U])),
+      t
+    );
+  }
+  /**
+   * Get the internal stack object.
+   * @internal
+   */
+  getInternalStack(t = this.theme) {
+    return this._stacks[t];
+  }
+  getScopes(t = this.theme) {
+    return Ae(this._stacks[t]);
+  }
+  toJSON() {
+    return {
+      lang: this.lang,
+      theme: this.theme,
+      themes: this.themes,
+      scopes: this.getScopes()
+    };
+  }
+}
+function Ae(n) {
+  const t = [], e = /* @__PURE__ */ new Set();
+  function s(r) {
+    var a;
+    if (e.has(r))
+      return;
+    e.add(r);
+    const o = (a = r == null ? void 0 : r.nameScopesList) == null ? void 0 : a.scopeName;
+    o && t.push(o), r.parent && s(r.parent);
+  }
+  return s(n), t;
+}
+function Be(n, t) {
+  if (!(n instanceof F))
+    throw new k("Invalid grammar state");
+  return n.getInternalStack(t);
+}
+function Me() {
+  const n = /* @__PURE__ */ new WeakMap();
+  function t(e) {
+    if (!n.has(e.meta)) {
+      let s = function(a) {
+        if (typeof a == "number") {
+          if (a < 0 || a > e.source.length)
+            throw new k(`Invalid decoration offset: ${a}. Code length: ${e.source.length}`);
+          return {
+            ...r.indexToPos(a),
+            offset: a
+          };
+        } else {
+          const i = r.lines[a.line];
+          if (i === void 0)
+            throw new k(`Invalid decoration position ${JSON.stringify(a)}. Lines length: ${r.lines.length}`);
+          let l = a.character;
+          if (l < 0 && (l = i.length + l), l < 0 || l > i.length)
+            throw new k(`Invalid decoration position ${JSON.stringify(a)}. Line ${a.line} length: ${i.length}`);
+          return {
+            ...a,
+            character: l,
+            offset: r.posToIndex(a.line, l)
+          };
+        }
+      };
+      const r = xe(e.source), o = (e.options.decorations || []).map((a) => ({
+        ...a,
+        start: s(a.start),
+        end: s(a.end)
+      }));
+      Oe(o), n.set(e.meta, {
+        decorations: o,
+        converter: r,
+        source: e.source
+      });
+    }
+    return n.get(e.meta);
+  }
+  return {
+    name: "shiki:decorations",
+    tokens(e) {
+      var a;
+      if (!((a = this.options.decorations) != null && a.length))
+        return;
+      const r = t(this).decorations.flatMap((i) => [i.start.offset, i.end.offset]);
+      return Ie(e, r);
+    },
+    code(e) {
+      var u;
+      if (!((u = this.options.decorations) != null && u.length))
+        return;
+      const s = t(this), r = Array.from(e.children).filter((f) => f.type === "element" && f.tagName === "span");
+      if (r.length !== s.converter.lines.length)
+        throw new k(`Number of lines in code element (${r.length}) does not match the number of lines in the source (${s.converter.lines.length}). Failed to apply decorations.`);
+      function o(f, h, d, m) {
+        const y = r[f];
+        let T = "", p = -1, b = -1;
+        if (h === 0 && (p = 0), d === 0 && (b = 0), d === Number.POSITIVE_INFINITY && (b = y.children.length), p === -1 || b === -1)
+          for (let S = 0; S < y.children.length; S++)
+            T += pe(y.children[S]), p === -1 && T.length === h && (p = S + 1), b === -1 && T.length === d && (b = S + 1);
+        if (p === -1)
+          throw new k(`Failed to find start index for decoration ${JSON.stringify(m.start)}`);
+        if (b === -1)
+          throw new k(`Failed to find end index for decoration ${JSON.stringify(m.end)}`);
+        const g = y.children.slice(p, b);
+        if (!m.alwaysWrap && g.length === y.children.length)
+          i(y, m, "line");
+        else if (!m.alwaysWrap && g.length === 1 && g[0].type === "element")
+          i(g[0], m, "token");
+        else {
+          const S = {
+            type: "element",
+            tagName: "span",
+            properties: {},
+            children: g
+          };
+          i(S, m, "wrapper"), y.children.splice(p, g.length, S);
+        }
+      }
+      function a(f, h) {
+        r[f] = i(r[f], h, "line");
+      }
+      function i(f, h, d) {
+        var T;
+        const m = h.properties || {}, y = h.transform || ((p) => p);
+        return f.tagName = h.tagName || "span", f.properties = {
+          ...f.properties,
+          ...m,
+          class: f.properties.class
+        }, (T = h.properties) != null && T.class && de(f, h.properties.class), f = y(f, d) || f, f;
+      }
+      const l = [], c = s.decorations.sort((f, h) => h.start.offset - f.start.offset || f.end.offset - h.end.offset);
+      for (const f of c) {
+        const { start: h, end: d } = f;
+        if (h.line === d.line)
+          o(h.line, h.character, d.character, f);
+        else if (h.line < d.line) {
+          o(h.line, h.character, Number.POSITIVE_INFINITY, f);
+          for (let m = h.line + 1; m < d.line; m++)
+            l.unshift(() => a(m, f));
+          o(d.line, 0, d.character, f);
+        }
+      }
+      l.forEach((f) => f());
+    }
+  };
+}
+function Oe(n) {
+  for (let t = 0; t < n.length; t++) {
+    const e = n[t];
+    if (e.start.offset > e.end.offset)
+      throw new k(`Invalid decoration range: ${JSON.stringify(e.start)} - ${JSON.stringify(e.end)}`);
+    for (let s = t + 1; s < n.length; s++) {
+      const r = n[s], o = e.start.offset <= r.start.offset && r.start.offset < e.end.offset, a = e.start.offset < r.end.offset && r.end.offset <= e.end.offset, i = r.start.offset <= e.start.offset && e.start.offset < r.end.offset, l = r.start.offset < e.end.offset && e.end.offset <= r.end.offset;
+      if (o || a || i || l) {
+        if (o && a || i && l || i && e.start.offset === e.end.offset || a && r.start.offset === r.end.offset)
+          continue;
+        throw new k(`Decorations ${JSON.stringify(e.start)} and ${JSON.stringify(r.start)} intersect.`);
+      }
+    }
+  }
+}
+function pe(n) {
+  return n.type === "text" ? n.value : n.type === "element" ? n.children.map(pe).join("") : "";
+}
+const je = [
+  /* @__PURE__ */ Me()
+];
+function H(n) {
+  const t = Fe(n.transformers || []);
+  return [
+    ...t.pre,
+    ...t.normal,
+    ...t.post,
+    ...je
+  ];
+}
+function Fe(n) {
+  const t = [], e = [], s = [];
+  for (const r of n)
+    switch (r.enforce) {
+      case "pre":
+        t.push(r);
+        break;
+      case "post":
+        e.push(r);
+        break;
+      default:
+        s.push(r);
+    }
+  return { pre: t, post: e, normal: s };
+}
+var A = [
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "brightBlack",
+  "brightRed",
+  "brightGreen",
+  "brightYellow",
+  "brightBlue",
+  "brightMagenta",
+  "brightCyan",
+  "brightWhite"
+], K = {
+  1: "bold",
+  2: "dim",
+  3: "italic",
+  4: "underline",
+  7: "reverse",
+  8: "hidden",
+  9: "strikethrough"
+};
+function Ge(n, t) {
+  const e = n.indexOf("\x1B", t);
+  if (e !== -1 && n[e + 1] === "[") {
+    const s = n.indexOf("m", e);
+    if (s !== -1)
+      return {
+        sequence: n.substring(e + 2, s).split(";"),
+        startPosition: e,
+        position: s + 1
+      };
+  }
+  return {
+    position: n.length
+  };
+}
+function oe(n) {
+  const t = n.shift();
+  if (t === "2") {
+    const e = n.splice(0, 3).map((s) => Number.parseInt(s));
+    return e.length !== 3 || e.some((s) => Number.isNaN(s)) ? void 0 : {
+      type: "rgb",
+      rgb: e
+    };
+  } else if (t === "5") {
+    const e = n.shift();
+    if (e)
+      return { type: "table", index: Number(e) };
+  }
+}
+function Re(n) {
+  const t = [];
+  for (; n.length > 0; ) {
+    const e = n.shift();
+    if (!e)
+      continue;
+    const s = Number.parseInt(e);
+    if (!Number.isNaN(s))
+      if (s === 0)
+        t.push({ type: "resetAll" });
+      else if (s <= 9)
+        K[s] && t.push({
+          type: "setDecoration",
+          value: K[s]
+        });
+      else if (s <= 29) {
+        const r = K[s - 20];
+        r && (t.push({
+          type: "resetDecoration",
+          value: r
+        }), r === "dim" && t.push({
+          type: "resetDecoration",
+          value: "bold"
+        }));
+      } else if (s <= 37)
+        t.push({
+          type: "setForegroundColor",
+          value: { type: "named", name: A[s - 30] }
+        });
+      else if (s === 38) {
+        const r = oe(n);
+        r && t.push({
+          type: "setForegroundColor",
+          value: r
+        });
+      } else if (s === 39)
+        t.push({
+          type: "resetForegroundColor"
+        });
+      else if (s <= 47)
+        t.push({
+          type: "setBackgroundColor",
+          value: { type: "named", name: A[s - 40] }
+        });
+      else if (s === 48) {
+        const r = oe(n);
+        r && t.push({
+          type: "setBackgroundColor",
+          value: r
+        });
+      } else s === 49 ? t.push({
+        type: "resetBackgroundColor"
+      }) : s === 53 ? t.push({
+        type: "setDecoration",
+        value: "overline"
+      }) : s === 55 ? t.push({
+        type: "resetDecoration",
+        value: "overline"
+      }) : s >= 90 && s <= 97 ? t.push({
+        type: "setForegroundColor",
+        value: { type: "named", name: A[s - 90 + 8] }
+      }) : s >= 100 && s <= 107 && t.push({
+        type: "setBackgroundColor",
+        value: { type: "named", name: A[s - 100 + 8] }
+      });
+  }
+  return t;
+}
+function De() {
+  let n = null, t = null, e = /* @__PURE__ */ new Set();
+  return {
+    parse(s) {
+      const r = [];
+      let o = 0;
+      do {
+        const a = Ge(s, o), i = a.sequence ? s.substring(o, a.startPosition) : s.substring(o);
+        if (i.length > 0 && r.push({
+          value: i,
+          foreground: n,
+          background: t,
+          decorations: new Set(e)
+        }), a.sequence) {
+          const l = Re(a.sequence);
+          for (const c of l)
+            c.type === "resetAll" ? (n = null, t = null, e.clear()) : c.type === "resetForegroundColor" ? n = null : c.type === "resetBackgroundColor" ? t = null : c.type === "resetDecoration" && e.delete(c.value);
+          for (const c of l)
+            c.type === "setForegroundColor" ? n = c.value : c.type === "setBackgroundColor" ? t = c.value : c.type === "setDecoration" && e.add(c.value);
+        }
+        o = a.position;
+      } while (o < s.length);
+      return r;
+    }
+  };
+}
+var We = {
+  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 He(n = We) {
+  function t(i) {
+    return n[i];
+  }
+  function e(i) {
+    return `#${i.map((l) => Math.max(0, Math.min(l, 255)).toString(16).padStart(2, "0")).join("")}`;
+  }
+  let s;
+  function r() {
+    if (s)
+      return s;
+    s = [];
+    for (let c = 0; c < A.length; c++)
+      s.push(t(A[c]));
+    let i = [0, 95, 135, 175, 215, 255];
+    for (let c = 0; c < 6; c++)
+      for (let u = 0; u < 6; u++)
+        for (let f = 0; f < 6; f++)
+          s.push(e([i[c], i[u], i[f]]));
+    let l = 8;
+    for (let c = 0; c < 24; c++, l += 10)
+      s.push(e([l, l, l]));
+    return s;
+  }
+  function o(i) {
+    return r()[i];
+  }
+  function a(i) {
+    switch (i.type) {
+      case "named":
+        return t(i.name);
+      case "rgb":
+        return e(i.rgb);
+      case "table":
+        return o(i.index);
+    }
+  }
+  return {
+    value: a
+  };
+}
+const Pe = {
+  black: "#000000",
+  red: "#cd3131",
+  green: "#0DBC79",
+  yellow: "#E5E510",
+  blue: "#2472C8",
+  magenta: "#BC3FBC",
+  cyan: "#11A8CD",
+  white: "#E5E5E5",
+  brightBlack: "#666666",
+  brightRed: "#F14C4C",
+  brightGreen: "#23D18B",
+  brightYellow: "#F5F543",
+  brightBlue: "#3B8EEA",
+  brightMagenta: "#D670D6",
+  brightCyan: "#29B8DB",
+  brightWhite: "#FFFFFF"
 };
+function ze(n, t, e) {
+  const s = D(n, e), r = V(t), o = Object.fromEntries(
+    A.map((l) => {
+      var f;
+      const c = `terminal.ansi${l[0].toUpperCase()}${l.substring(1)}`, u = (f = n.colors) == null ? void 0 : f[c];
+      return [l, u || Pe[l]];
+    })
+  ), a = He(o), i = De();
+  return r.map(
+    (l) => i.parse(l[0]).map((c) => {
+      let u, f;
+      c.decorations.has("reverse") ? (u = c.background ? a.value(c.background) : n.bg, f = c.foreground ? a.value(c.foreground) : n.fg) : (u = c.foreground ? a.value(c.foreground) : n.fg, f = c.background ? a.value(c.background) : void 0), u = E(u, s), f = E(f, s), c.decorations.has("dim") && (u = Ve(u));
+      let h = L.None;
+      return c.decorations.has("bold") && (h |= L.Bold), c.decorations.has("italic") && (h |= L.Italic), c.decorations.has("underline") && (h |= L.Underline), c.decorations.has("strikethrough") && (h |= L.Strikethrough), {
+        content: c.value,
+        offset: l[1],
+        // TODO: more accurate offset? might need to fork ansi-sequence-parser
+        color: u,
+        bgColor: f,
+        fontStyle: h
+      };
+    })
+  );
+}
+function Ve(n) {
+  const t = n.match(/#([0-9a-f]{3,8})/i);
+  if (t) {
+    const s = t[1];
+    if (s.length === 8) {
+      const r = Math.round(Number.parseInt(s.slice(6, 8), 16) / 2).toString(16).padStart(2, "0");
+      return `#${s.slice(0, 6)}${r}`;
+    } else {
+      if (s.length === 6)
+        return `#${s}80`;
+      if (s.length === 4) {
+        const r = s[0], o = s[1], a = s[2], i = s[3], l = Math.round(Number.parseInt(`${i}${i}`, 16) / 2).toString(16).padStart(2, "0");
+        return `#${r}${r}${o}${o}${a}${a}${l}`;
+      } else if (s.length === 3) {
+        const r = s[0], o = s[1], a = s[2];
+        return `#${r}${r}${o}${o}${a}${a}80`;
+      }
+    }
+  }
+  const e = n.match(/var\((--[\w-]+-ansi-[\w-]+)\)/);
+  return e ? `var(${e[1]}-dim)` : n;
+}
+function ee(n, t, e = {}) {
+  const {
+    theme: s = n.getLoadedThemes()[0]
+  } = e, r = n.resolveLangAlias(e.lang || "text");
+  if (Q(r) || X(s))
+    return V(t).map((l) => [{ content: l[0], offset: l[1] }]);
+  const { theme: o, colorMap: a } = n.setTheme(s);
+  if (r === "ansi")
+    return ze(o, t, e);
+  const i = n.getLanguage(e.lang || "text");
+  if (e.grammarState) {
+    if (e.grammarState.lang !== i.name)
+      throw new k(`Grammar state language "${e.grammarState.lang}" does not match highlight language "${i.name}"`);
+    if (!e.grammarState.themes.includes(o.name))
+      throw new k(`Grammar state themes "${e.grammarState.themes}" do not contain highlight theme "${o.name}"`);
+  }
+  return Ye(t, i, o, a, e);
+}
+function Je(...n) {
+  if (n.length === 2)
+    return R(n[1]);
+  const [t, e, s = {}] = n, {
+    lang: r = "text",
+    theme: o = t.getLoadedThemes()[0]
+  } = s;
+  if (Q(r) || X(o))
+    throw new k("Plain language does not have grammar state");
+  if (r === "ansi")
+    throw new k("ANSI language does not have grammar state");
+  const { theme: a, colorMap: i } = t.setTheme(o), l = t.getLanguage(r);
+  return new F(
+    te(e, l, a, i, s).stateStack,
+    l.name,
+    a.name
+  );
+}
+function Ye(n, t, e, s, r) {
+  const o = te(n, t, e, s, r), a = new F(
+    o.stateStack,
+    t.name,
+    e.name
+  );
+  return J(o.tokens, a), o.tokens;
+}
+function te(n, t, e, s, r) {
+  const o = D(e, r), {
+    tokenizeMaxLineLength: a = 0,
+    tokenizeTimeLimit: i = 500
+  } = r, l = V(n);
+  let c = r.grammarState ? Be(r.grammarState, e.name) ?? U : r.grammarContextCode != null ? te(
+    r.grammarContextCode,
+    t,
+    e,
+    s,
+    {
+      ...r,
+      grammarState: void 0,
+      grammarContextCode: void 0
+    }
+  ).stateStack : U, u = [];
+  const f = [];
+  for (let h = 0, d = l.length; h < d; h++) {
+    const [m, y] = l[h];
+    if (m === "") {
+      u = [], f.push([]);
+      continue;
+    }
+    if (a > 0 && m.length >= a) {
+      u = [], f.push([{
+        content: m,
+        offset: y,
+        color: "",
+        fontStyle: 0
+      }]);
+      continue;
+    }
+    let T, p, b;
+    r.includeExplanation && (T = t.tokenizeLine(m, c, i), p = T.tokens, b = 0);
+    const g = t.tokenizeLine2(m, c, i), S = g.tokens.length / 2;
+    for (let _ = 0; _ < S; _++) {
+      const C = g.tokens[2 * _], w = _ + 1 < S ? g.tokens[2 * _ + 2] : m.length;
+      if (C === w)
+        continue;
+      const N = g.tokens[2 * _ + 1], x = E(
+        s[re.getForeground(N)],
+        o
+      ), I = re.getFontStyle(N), B = {
+        content: m.substring(C, w),
+        offset: y + C,
+        color: x,
+        fontStyle: I
+      };
+      if (r.includeExplanation) {
+        const M = [];
+        if (r.includeExplanation !== "scopeName")
+          for (const $ of e.settings) {
+            let O;
+            switch (typeof $.scope) {
+              case "string":
+                O = $.scope.split(/,/).map((Y) => Y.trim());
+                break;
+              case "object":
+                O = $.scope;
+                break;
+              default:
+                continue;
+            }
+            M.push({
+              settings: $,
+              selectors: O.map((Y) => Y.split(/ /))
+            });
+          }
+        B.explanation = [];
+        let se = 0;
+        for (; C + se < w; ) {
+          const $ = p[b], O = m.substring(
+            $.startIndex,
+            $.endIndex
+          );
+          se += O.length, B.explanation.push({
+            content: O,
+            scopes: r.includeExplanation === "scopeName" ? Ke(
+              $.scopes
+            ) : Ue(
+              M,
+              $.scopes
+            )
+          }), b += 1;
+        }
+      }
+      u.push(B);
+    }
+    f.push(u), u = [], c = g.ruleStack;
+  }
+  return {
+    tokens: f,
+    stateStack: c
+  };
+}
+function Ke(n) {
+  return n.map((t) => ({ scopeName: t }));
+}
+function Ue(n, t) {
+  const e = [];
+  for (let s = 0, r = t.length; s < r; s++) {
+    const o = t[s];
+    e[s] = {
+      scopeName: o,
+      themeMatches: Qe(n, o, t.slice(0, s))
+    };
+  }
+  return e;
+}
+function ae(n, t) {
+  return n === t || t.substring(0, n.length) === n && t[n.length] === ".";
+}
+function qe(n, t, e) {
+  if (!ae(n[n.length - 1], t))
+    return !1;
+  let s = n.length - 2, r = e.length - 1;
+  for (; s >= 0 && r >= 0; )
+    ae(n[s], e[r]) && (s -= 1), r -= 1;
+  return s === -1;
+}
+function Qe(n, t, e) {
+  const s = [];
+  for (const { selectors: r, settings: o } of n)
+    for (const a of r)
+      if (qe(a, t, e)) {
+        s.push(o);
+        break;
+      }
+  return s;
+}
+function ye(n, t, e) {
+  const s = Object.entries(e.themes).filter((l) => l[1]).map((l) => ({ color: l[0], theme: l[1] })), r = s.map((l) => {
+    const c = ee(n, t, {
+      ...e,
+      theme: l.theme
+    }), u = R(c), f = typeof l.theme == "string" ? l.theme : l.theme.name;
+    return {
+      tokens: c,
+      state: u,
+      theme: f
+    };
+  }), o = Xe(
+    ...r.map((l) => l.tokens)
+  ), a = o[0].map(
+    (l, c) => l.map((u, f) => {
+      const h = {
+        content: u.content,
+        variants: {},
+        offset: u.offset
+      };
+      return "includeExplanation" in e && e.includeExplanation && (h.explanation = u.explanation), o.forEach((d, m) => {
+        const {
+          content: y,
+          explanation: T,
+          offset: p,
+          ...b
+        } = d[c][f];
+        h.variants[s[m].color] = b;
+      }), h;
+    })
+  ), i = r[0].state ? new F(
+    Object.fromEntries(r.map((l) => {
+      var c;
+      return [l.theme, (c = l.state) == null ? void 0 : c.getInternalStack(l.theme)];
+    })),
+    r[0].state.lang
+  ) : void 0;
+  return i && J(a, i), a;
+}
+function Xe(...n) {
+  const t = n.map(() => []), e = n.length;
+  for (let s = 0; s < n[0].length; s++) {
+    const r = n.map((l) => l[s]), o = t.map(() => []);
+    t.forEach((l, c) => l.push(o[c]));
+    const a = r.map(() => 0), i = r.map((l) => l[0]);
+    for (; i.every((l) => l); ) {
+      const l = Math.min(...i.map((c) => c.content.length));
+      for (let c = 0; c < e; c++) {
+        const u = i[c];
+        u.content.length === l ? (o[c].push(u), a[c] += 1, i[c] = r[c][a[c]]) : (o[c].push({
+          ...u,
+          content: u.content.slice(0, l)
+        }), i[c] = {
+          ...u,
+          content: u.content.slice(l),
+          offset: u.offset + l
+        });
+      }
+    }
+  }
+  return t;
+}
+function P(n, t, e) {
+  let s, r, o, a, i, l;
+  if ("themes" in e) {
+    const {
+      defaultColor: c = "light",
+      cssVariablePrefix: u = "--shiki-",
+      colorsRendering: f = "css-vars"
+    } = e, h = Object.entries(e.themes).filter((p) => p[1]).map((p) => ({ color: p[0], theme: p[1] })).sort((p, b) => p.color === c ? -1 : b.color === c ? 1 : 0);
+    if (h.length === 0)
+      throw new k("`themes` option must not be empty");
+    const d = ye(
+      n,
+      t,
+      e
+    );
+    if (l = R(d), c && Z !== c && !h.find((p) => p.color === c))
+      throw new k(`\`themes\` option must contain the defaultColor key \`${c}\``);
+    const m = h.map((p) => n.getTheme(p.theme)), y = h.map((p) => p.color);
+    o = d.map((p) => p.map((b) => Ee(b, y, u, c, f))), l && J(o, l);
+    const T = h.map((p) => D(p.theme, e));
+    r = ie(h, m, T, u, c, "fg", f), s = ie(h, m, T, u, c, "bg", f), a = `shiki-themes ${m.map((p) => p.name).join(" ")}`, i = c ? void 0 : [r, s].join(";");
+  } else if ("theme" in e) {
+    const c = D(e.theme, e);
+    o = ee(
+      n,
+      t,
+      e
+    );
+    const u = n.getTheme(e.theme);
+    s = E(u.bg, c), r = E(u.fg, c), a = u.name, l = R(o);
+  } else
+    throw new k("Invalid options, either `theme` or `themes` must be provided");
+  return {
+    tokens: o,
+    fg: r,
+    bg: s,
+    themeName: a,
+    rootStyle: i,
+    grammarState: l
+  };
+}
+function ie(n, t, e, s, r, o, a) {
+  return n.map((i, l) => {
+    const c = E(t[l][o], e[l]) || "inherit", u = `${s + i.color}${o === "bg" ? "-bg" : ""}:${c}`;
+    if (l === 0 && r) {
+      if (r === Z && n.length > 1) {
+        const f = n.findIndex((y) => y.color === "light"), h = n.findIndex((y) => y.color === "dark");
+        if (f === -1 || h === -1)
+          throw new k('When using `defaultColor: "light-dark()"`, you must provide both `light` and `dark` themes');
+        const d = E(t[f][o], e[f]) || "inherit", m = E(t[h][o], e[h]) || "inherit";
+        return `light-dark(${d}, ${m});${u}`;
+      }
+      return c;
+    }
+    return a === "css-vars" ? u : null;
+  }).filter((i) => !!i).join(";");
+}
+function z(n, t, e, s = {
+  meta: {},
+  options: e,
+  codeToHast: (r, o) => z(n, r, o),
+  codeToTokens: (r, o) => P(n, r, o)
+}) {
+  var m, y;
+  let r = t;
+  for (const T of H(e))
+    r = ((m = T.preprocess) == null ? void 0 : m.call(s, r, e)) || r;
+  let {
+    tokens: o,
+    fg: a,
+    bg: i,
+    themeName: l,
+    rootStyle: c,
+    grammarState: u
+  } = P(n, r, e);
+  const {
+    mergeWhitespaces: f = !0,
+    mergeSameStyleTokens: h = !1
+  } = e;
+  f === !0 ? o = et(o) : f === "never" && (o = tt(o)), h && (o = nt(o));
+  const d = {
+    ...s,
+    get source() {
+      return r;
+    }
+  };
+  for (const T of H(e))
+    o = ((y = T.tokens) == null ? void 0 : y.call(d, o)) || o;
+  return Ze(
+    o,
+    {
+      ...e,
+      fg: a,
+      bg: i,
+      themeName: l,
+      rootStyle: e.rootStyle === !1 ? !1 : e.rootStyle ?? c
+    },
+    d,
+    u
+  );
+}
+function Ze(n, t, e, s = R(n)) {
+  var y, T, p, b;
+  const r = H(t), o = [], a = {
+    type: "root",
+    children: []
+  }, {
+    structure: i = "classic",
+    tabindex: l = "0"
+  } = t, c = {
+    class: `shiki ${t.themeName || ""}`
+  };
+  t.rootStyle !== !1 && (t.rootStyle != null ? c.style = t.rootStyle : c.style = `background-color:${t.bg};color:${t.fg}`), l !== !1 && l != null && (c.tabindex = l.toString());
+  for (const [g, S] of Object.entries(t.meta || {}))
+    g.startsWith("_") || (c[g] = S);
+  let u = {
+    type: "element",
+    tagName: "pre",
+    properties: c,
+    children: [],
+    data: t.data
+  }, f = {
+    type: "element",
+    tagName: "code",
+    properties: {},
+    children: o
+  };
+  const h = [], d = {
+    ...e,
+    structure: i,
+    addClassToHast: de,
+    get source() {
+      return e.source;
+    },
+    get tokens() {
+      return n;
+    },
+    get options() {
+      return t;
+    },
+    get root() {
+      return a;
+    },
+    get pre() {
+      return u;
+    },
+    get code() {
+      return f;
+    },
+    get lines() {
+      return h;
+    }
+  };
+  if (n.forEach((g, S) => {
+    var w, N;
+    S && (i === "inline" ? a.children.push({ type: "element", tagName: "br", properties: {}, children: [] }) : i === "classic" && o.push({ type: "text", value: `
+` }));
+    let _ = {
+      type: "element",
+      tagName: "span",
+      properties: { class: "line" },
+      children: []
+    }, C = 0;
+    for (const x of g) {
+      let I = {
+        type: "element",
+        tagName: "span",
+        properties: {
+          ...x.htmlAttrs
+        },
+        children: [{ type: "text", value: x.content }]
+      };
+      const B = q(x.htmlStyle || W(x));
+      B && (I.properties.style = B);
+      for (const M of r)
+        I = ((w = M == null ? void 0 : M.span) == null ? void 0 : w.call(d, I, S + 1, C, _, x)) || I;
+      i === "inline" ? a.children.push(I) : i === "classic" && _.children.push(I), C += x.content.length;
+    }
+    if (i === "classic") {
+      for (const x of r)
+        _ = ((N = x == null ? void 0 : x.line) == null ? void 0 : N.call(d, _, S + 1)) || _;
+      h.push(_), o.push(_);
+    } else i === "inline" && h.push(_);
+  }), i === "classic") {
+    for (const g of r)
+      f = ((y = g == null ? void 0 : g.code) == null ? void 0 : y.call(d, f)) || f;
+    u.children.push(f);
+    for (const g of r)
+      u = ((T = g == null ? void 0 : g.pre) == null ? void 0 : T.call(d, u)) || u;
+    a.children.push(u);
+  } else if (i === "inline") {
+    const g = [];
+    let S = {
+      type: "element",
+      tagName: "span",
+      properties: { class: "line" },
+      children: []
+    };
+    for (const w of a.children)
+      w.type === "element" && w.tagName === "br" ? (g.push(S), S = {
+        type: "element",
+        tagName: "span",
+        properties: { class: "line" },
+        children: []
+      }) : (w.type === "element" || w.type === "text") && S.children.push(w);
+    g.push(S);
+    let C = {
+      type: "element",
+      tagName: "code",
+      properties: {},
+      children: g
+    };
+    for (const w of r)
+      C = ((p = w == null ? void 0 : w.code) == null ? void 0 : p.call(d, C)) || C;
+    a.children = [];
+    for (let w = 0; w < C.children.length; w++) {
+      w > 0 && a.children.push({ type: "element", tagName: "br", properties: {}, children: [] });
+      const N = C.children[w];
+      N.type === "element" && a.children.push(...N.children);
+    }
+  }
+  let m = a;
+  for (const g of r)
+    m = ((b = g == null ? void 0 : g.root) == null ? void 0 : b.call(d, m)) || m;
+  return s && J(m, s), m;
+}
+function et(n) {
+  return n.map((t) => {
+    const e = [];
+    let s = "", r;
+    return t.forEach((o, a) => {
+      const l = !(o.fontStyle && (o.fontStyle & L.Underline || o.fontStyle & L.Strikethrough));
+      l && o.content.match(/^\s+$/) && t[a + 1] ? (r === void 0 && (r = o.offset), s += o.content) : s ? (l ? e.push({
+        ...o,
+        offset: r,
+        content: s + o.content
+      }) : e.push(
+        {
+          content: s,
+          offset: r
+        },
+        o
+      ), r = void 0, s = "") : e.push(o);
+    }), e;
+  });
+}
+function tt(n) {
+  return n.map((t) => t.flatMap((e) => {
+    if (e.content.match(/^\s+$/))
+      return e;
+    const s = e.content.match(/^(\s*)(.*?)(\s*)$/);
+    if (!s)
+      return e;
+    const [, r, o, a] = s;
+    if (!r && !a)
+      return e;
+    const i = [{
+      ...e,
+      offset: e.offset + r.length,
+      content: o
+    }];
+    return r && i.unshift({
+      content: r,
+      offset: e.offset
+    }), a && i.push({
+      content: a,
+      offset: e.offset + r.length + o.length
+    }), i;
+  }));
+}
+function nt(n) {
+  return n.map((t) => {
+    const e = [];
+    for (const s of t) {
+      if (e.length === 0) {
+        e.push({ ...s });
+        continue;
+      }
+      const r = e[e.length - 1], o = q(r.htmlStyle || W(r)), a = q(s.htmlStyle || W(s)), i = r.fontStyle && (r.fontStyle & L.Underline || r.fontStyle & L.Strikethrough), l = s.fontStyle && (s.fontStyle & L.Underline || s.fontStyle & L.Strikethrough);
+      !i && !l && o === a ? r.content += s.content : e.push({ ...s });
+    }
+    return e;
+  });
+}
+const st = ve;
+function rt(n, t, e) {
+  var o;
+  const s = {
+    meta: {},
+    options: e,
+    codeToHast: (a, i) => z(n, a, i),
+    codeToTokens: (a, i) => P(n, a, i)
+  };
+  let r = st(z(n, t, e, s));
+  for (const a of H(e))
+    r = ((o = a.postprocess) == null ? void 0 : o.call(s, r, e)) || r;
+  return r;
+}
+const le = { light: "#333333", dark: "#bbbbbb" }, ce = { light: "#fffffe", dark: "#1e1e1e" }, fe = "__shiki_resolved";
+function ne(n) {
+  var i, l, c, u, f;
+  if (n != null && n[fe])
+    return n;
+  const t = {
+    ...n
+  };
+  t.tokenColors && !t.settings && (t.settings = t.tokenColors, delete t.tokenColors), t.type || (t.type = "dark"), t.colorReplacements = { ...t.colorReplacements }, t.settings || (t.settings = []);
+  let { bg: e, fg: s } = t;
+  if (!e || !s) {
+    const h = t.settings ? t.settings.find((d) => !d.name && !d.scope) : void 0;
+    (i = h == null ? void 0 : h.settings) != null && i.foreground && (s = h.settings.foreground), (l = h == null ? void 0 : h.settings) != null && l.background && (e = h.settings.background), !s && ((c = t == null ? void 0 : t.colors) != null && c["editor.foreground"]) && (s = t.colors["editor.foreground"]), !e && ((u = t == null ? void 0 : t.colors) != null && u["editor.background"]) && (e = t.colors["editor.background"]), s || (s = t.type === "light" ? le.light : le.dark), e || (e = t.type === "light" ? ce.light : ce.dark), t.fg = s, t.bg = e;
+  }
+  t.settings[0] && t.settings[0].settings && !t.settings[0].scope || t.settings.unshift({
+    settings: {
+      foreground: t.fg,
+      background: t.bg
+    }
+  });
+  let r = 0;
+  const o = /* @__PURE__ */ new Map();
+  function a(h) {
+    var m;
+    if (o.has(h))
+      return o.get(h);
+    r += 1;
+    const d = `#${r.toString(16).padStart(8, "0").toLowerCase()}`;
+    return (m = t.colorReplacements) != null && m[`#${d}`] ? a(h) : (o.set(h, d), d);
+  }
+  t.settings = t.settings.map((h) => {
+    var T, p;
+    const d = ((T = h.settings) == null ? void 0 : T.foreground) && !h.settings.foreground.startsWith("#"), m = ((p = h.settings) == null ? void 0 : p.background) && !h.settings.background.startsWith("#");
+    if (!d && !m)
+      return h;
+    const y = {
+      ...h,
+      settings: {
+        ...h.settings
+      }
+    };
+    if (d) {
+      const b = a(h.settings.foreground);
+      t.colorReplacements[b] = h.settings.foreground, y.settings.foreground = b;
+    }
+    if (m) {
+      const b = a(h.settings.background);
+      t.colorReplacements[b] = h.settings.background, y.settings.background = b;
+    }
+    return y;
+  });
+  for (const h of Object.keys(t.colors || {}))
+    if ((h === "editor.foreground" || h === "editor.background" || h.startsWith("terminal.ansi")) && !((f = t.colors[h]) != null && f.startsWith("#"))) {
+      const d = a(t.colors[h]);
+      t.colorReplacements[d] = t.colors[h], t.colors[h] = d;
+    }
+  return Object.defineProperty(t, fe, {
+    enumerable: !1,
+    writable: !1,
+    value: !0
+  }), t;
+}
+async function be(n) {
+  return Array.from(new Set((await Promise.all(
+    n.filter((t) => !ue(t)).map(async (t) => await he(t).then((e) => Array.isArray(e) ? e : [e]))
+  )).flat()));
+}
+async function Se(n) {
+  return (await Promise.all(
+    n.map(
+      async (e) => ge(e) ? null : ne(await he(e))
+    )
+  )).filter((e) => !!e);
+}
+let ot = 3;
+function at(n, t = 3) {
+  t > ot || console.trace(`[SHIKI DEPRECATE]: ${n}`);
+}
+class j extends Error {
+  constructor(t) {
+    super(t), this.name = "ShikiError";
+  }
+}
+function Te(n, t) {
+  if (!t)
+    return n;
+  if (t[n]) {
+    const e = /* @__PURE__ */ new Set([n]);
+    for (; t[n]; ) {
+      if (n = t[n], e.has(n))
+        throw new j(`Circular alias \`${Array.from(e).join(" -> ")} -> ${n}\``);
+      e.add(n);
+    }
+  }
+  return n;
+}
+class it extends _e {
+  constructor(e, s, r, o = {}) {
+    super(e);
+    v(this, "_resolvedThemes", /* @__PURE__ */ new Map());
+    v(this, "_resolvedGrammars", /* @__PURE__ */ new Map());
+    v(this, "_langMap", /* @__PURE__ */ new Map());
+    v(this, "_langGraph", /* @__PURE__ */ new Map());
+    v(this, "_textmateThemeCache", /* @__PURE__ */ new WeakMap());
+    v(this, "_loadedThemesCache", null);
+    v(this, "_loadedLanguagesCache", null);
+    this._resolver = e, this._themes = s, this._langs = r, this._alias = o, this._themes.map((a) => this.loadTheme(a)), this.loadLanguages(this._langs);
+  }
+  getTheme(e) {
+    return typeof e == "string" ? this._resolvedThemes.get(e) : this.loadTheme(e);
+  }
+  loadTheme(e) {
+    const s = ne(e);
+    return s.name && (this._resolvedThemes.set(s.name, s), this._loadedThemesCache = null), s;
+  }
+  getLoadedThemes() {
+    return this._loadedThemesCache || (this._loadedThemesCache = [...this._resolvedThemes.keys()]), this._loadedThemesCache;
+  }
+  // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
+  // is expensive. Themes can switch often especially for dual-theme support.
+  //
+  // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,
+  // we omit here so it's easier to cache the themes.
+  setTheme(e) {
+    let s = this._textmateThemeCache.get(e);
+    s || (s = Le.createFromRawTheme(e), this._textmateThemeCache.set(e, s)), this._syncRegistry.setTheme(s);
+  }
+  getGrammar(e) {
+    return e = Te(e, this._alias), this._resolvedGrammars.get(e);
+  }
+  loadLanguage(e) {
+    var a, i, l, c;
+    if (this.getGrammar(e.name))
+      return;
+    const s = new Set(
+      [...this._langMap.values()].filter((u) => {
+        var f;
+        return (f = u.embeddedLangsLazy) == null ? void 0 : f.includes(e.name);
+      })
+    );
+    this._resolver.addLanguage(e);
+    const r = {
+      balancedBracketSelectors: e.balancedBracketSelectors || ["*"],
+      unbalancedBracketSelectors: e.unbalancedBracketSelectors || []
+    };
+    this._syncRegistry._rawGrammars.set(e.scopeName, e);
+    const o = this.loadGrammarWithConfiguration(e.scopeName, 1, r);
+    if (o.name = e.name, this._resolvedGrammars.set(e.name, o), e.aliases && e.aliases.forEach((u) => {
+      this._alias[u] = e.name;
+    }), this._loadedLanguagesCache = null, s.size)
+      for (const u of s)
+        this._resolvedGrammars.delete(u.name), this._loadedLanguagesCache = null, (i = (a = this._syncRegistry) == null ? void 0 : a._injectionGrammars) == null || i.delete(u.scopeName), (c = (l = this._syncRegistry) == null ? void 0 : l._grammars) == null || c.delete(u.scopeName), this.loadLanguage(this._langMap.get(u.name));
+  }
+  dispose() {
+    super.dispose(), this._resolvedThemes.clear(), this._resolvedGrammars.clear(), this._langMap.clear(), this._langGraph.clear(), this._loadedThemesCache = null;
+  }
+  loadLanguages(e) {
+    for (const o of e)
+      this.resolveEmbeddedLanguages(o);
+    const s = Array.from(this._langGraph.entries()), r = s.filter(([o, a]) => !a);
+    if (r.length) {
+      const o = s.filter(([a, i]) => {
+        if (!i)
+          return !1;
+        const l = i.embeddedLanguages || i.embeddedLangs;
+        return l == null ? void 0 : l.some((c) => r.map(([u]) => u).includes(c));
+      }).filter((a) => !r.includes(a));
+      throw new j(`Missing languages ${r.map(([a]) => `\`${a}\``).join(", ")}, required by ${o.map(([a]) => `\`${a}\``).join(", ")}`);
+    }
+    for (const [o, a] of s)
+      this._resolver.addLanguage(a);
+    for (const [o, a] of s)
+      this.loadLanguage(a);
+  }
+  getLoadedLanguages() {
+    return this._loadedLanguagesCache || (this._loadedLanguagesCache = [
+      .../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])
+    ]), this._loadedLanguagesCache;
+  }
+  resolveEmbeddedLanguages(e) {
+    this._langMap.set(e.name, e), this._langGraph.set(e.name, e);
+    const s = e.embeddedLanguages ?? e.embeddedLangs;
+    if (s)
+      for (const r of s)
+        this._langGraph.set(r, this._langMap.get(r));
+  }
+}
+class lt {
+  constructor(t, e) {
+    v(this, "_langs", /* @__PURE__ */ new Map());
+    v(this, "_scopeToLang", /* @__PURE__ */ new Map());
+    v(this, "_injections", /* @__PURE__ */ new Map());
+    v(this, "_onigLib");
+    this._onigLib = {
+      createOnigScanner: (s) => t.createScanner(s),
+      createOnigString: (s) => t.createString(s)
+    }, e.forEach((s) => this.addLanguage(s));
+  }
+  get onigLib() {
+    return this._onigLib;
+  }
+  getLangRegistration(t) {
+    return this._langs.get(t);
+  }
+  loadGrammar(t) {
+    return this._scopeToLang.get(t);
+  }
+  addLanguage(t) {
+    this._langs.set(t.name, t), t.aliases && t.aliases.forEach((e) => {
+      this._langs.set(e, t);
+    }), this._scopeToLang.set(t.scopeName, t), t.injectTo && t.injectTo.forEach((e) => {
+      this._injections.get(e) || this._injections.set(e, []), this._injections.get(e).push(t.scopeName);
+    });
+  }
+  getInjections(t) {
+    const e = t.split(".");
+    let s = [];
+    for (let r = 1; r <= e.length; r++) {
+      const o = e.slice(0, r).join(".");
+      s = [...s, ...this._injections.get(o) || []];
+    }
+    return s;
+  }
+}
+let G = 0;
+function ct(n) {
+  G += 1, n.warnings !== !1 && G >= 10 && G % 10 === 0 && console.warn(`[Shiki] ${G} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
+  let t = !1;
+  if (!n.engine)
+    throw new j("`engine` option is required for synchronous mode");
+  const e = (n.langs || []).flat(1), s = (n.themes || []).flat(1).map(ne), r = new lt(n.engine, e), o = new it(r, s, e, n.langAlias);
+  let a;
+  function i(g) {
+    return Te(g, n.langAlias);
+  }
+  function l(g) {
+    p();
+    const S = o.getGrammar(typeof g == "string" ? g : g.name);
+    if (!S)
+      throw new j(`Language \`${g}\` not found, you may need to load it first`);
+    return S;
+  }
+  function c(g) {
+    if (g === "none")
+      return { bg: "", fg: "", name: "none", settings: [], type: "dark" };
+    p();
+    const S = o.getTheme(g);
+    if (!S)
+      throw new j(`Theme \`${g}\` not found, you may need to load it first`);
+    return S;
+  }
+  function u(g) {
+    p();
+    const S = c(g);
+    a !== g && (o.setTheme(S), a = g);
+    const _ = o.getColorMap();
+    return {
+      theme: S,
+      colorMap: _
+    };
+  }
+  function f() {
+    return p(), o.getLoadedThemes();
+  }
+  function h() {
+    return p(), o.getLoadedLanguages();
+  }
+  function d(...g) {
+    p(), o.loadLanguages(g.flat(1));
+  }
+  async function m(...g) {
+    return d(await be(g));
+  }
+  function y(...g) {
+    p();
+    for (const S of g.flat(1))
+      o.loadTheme(S);
+  }
+  async function T(...g) {
+    return p(), y(await Se(g));
+  }
+  function p() {
+    if (t)
+      throw new j("Shiki instance has been disposed");
+  }
+  function b() {
+    t || (t = !0, o.dispose(), G -= 1);
+  }
+  return {
+    setTheme: u,
+    getTheme: c,
+    getLanguage: l,
+    getLoadedThemes: f,
+    getLoadedLanguages: h,
+    resolveLangAlias: i,
+    loadLanguage: m,
+    loadLanguageSync: d,
+    loadTheme: T,
+    loadThemeSync: y,
+    dispose: b,
+    [Symbol.dispose]: b
+  };
+}
+async function ft(n) {
+  n.engine || at("`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.");
+  const [
+    t,
+    e,
+    s
+  ] = await Promise.all([
+    Se(n.themes || []),
+    be(n.langs || []),
+    n.engine
+  ]);
+  return ct({
+    ...n,
+    themes: t,
+    langs: e,
+    engine: s
+  });
+}
+async function ht(n) {
+  const t = await ft(n);
+  return {
+    getLastGrammarState: (...e) => Je(t, ...e),
+    codeToTokensBase: (e, s) => ee(t, e, s),
+    codeToTokensWithThemes: (e, s) => ye(t, e, s),
+    codeToTokens: (e, s) => P(t, e, s),
+    codeToHast: (e, s) => z(t, e, s),
+    codeToHtml: (e, s) => rt(t, e, s),
+    getBundledLanguages: () => ({}),
+    getBundledThemes: () => ({}),
+    ...t,
+    getInternalContext: () => t
+  };
+}
+function bt(n) {
+  const t = n.langs, e = n.themes, s = n.engine;
+  async function r(o) {
+    function a(f) {
+      var h;
+      if (typeof f == "string") {
+        if (f = ((h = o.langAlias) == null ? void 0 : h[f]) || f, ue(f))
+          return [];
+        const d = t[f];
+        if (!d)
+          throw new k(`Language \`${f}\` is not included in this bundle. You may want to load it from external source.`);
+        return d;
+      }
+      return f;
+    }
+    function i(f) {
+      if (ge(f))
+        return "none";
+      if (typeof f == "string") {
+        const h = e[f];
+        if (!h)
+          throw new k(`Theme \`${f}\` is not included in this bundle. You may want to load it from external source.`);
+        return h;
+      }
+      return f;
+    }
+    const l = (o.themes ?? []).map((f) => i(f)), c = (o.langs ?? []).map((f) => a(f)), u = await ht({
+      engine: o.engine ?? s(),
+      ...o,
+      themes: l,
+      langs: c
+    });
+    return {
+      ...u,
+      loadLanguage(...f) {
+        return u.loadLanguage(...f.map(a));
+      },
+      loadTheme(...f) {
+        return u.loadTheme(...f.map(i));
+      },
+      getBundledLanguages() {
+        return t;
+      },
+      getBundledThemes() {
+        return e;
+      }
+    };
+  }
+  return r;
+}
+function ut(n) {
+  let t;
+  async function e(s = {}) {
+    if (t) {
+      const r = await t;
+      return await Promise.all([
+        r.loadTheme(...s.themes || []),
+        r.loadLanguage(...s.langs || [])
+      ]), r;
+    } else {
+      t = n({
+        ...s,
+        themes: [],
+        langs: []
+      });
+      const r = await t;
+      return await Promise.all([
+        r.loadTheme(...s.themes || []),
+        r.loadLanguage(...s.langs || [])
+      ]), r;
+    }
+  }
+  return e;
+}
+function St(n, t) {
+  const e = ut(n);
+  async function s(r, o) {
+    var l;
+    const a = await e({
+      langs: [o.lang],
+      themes: "theme" in o ? [o.theme] : Object.values(o.themes)
+    }), i = await ((l = t == null ? void 0 : t.guessEmbeddedLanguages) == null ? void 0 : l.call(t, r, o.lang, a));
+    return i && await a.loadLanguage(...i), a;
+  }
+  return {
+    getSingletonHighlighter(r) {
+      return e(r);
+    },
+    async codeToHtml(r, o) {
+      return (await s(r, o)).codeToHtml(r, o);
+    },
+    async codeToHast(r, o) {
+      return (await s(r, o)).codeToHast(r, o);
+    },
+    async codeToTokens(r, o) {
+      return (await s(r, o)).codeToTokens(r, o);
+    },
+    async codeToTokensBase(r, o) {
+      return (await s(r, o)).codeToTokensBase(r, o);
+    },
+    async codeToTokensWithThemes(r, o) {
+      return (await s(r, o)).codeToTokensWithThemes(r, o);
+    },
+    async getLastGrammarState(r, o) {
+      return (await e({
+        langs: [o.lang],
+        themes: [o.theme]
+      })).getLastGrammarState(r, o);
+    }
+  };
+}
 export {
-  e as bundledLanguages,
-  a as bundledLanguagesAlias,
-  o as bundledLanguagesBase,
-  r as bundledLanguagesInfo
+  k as ShikiError,
+  de as addClassToHast,
+  E as applyColorReplacements,
+  z as codeToHast,
+  rt as codeToHtml,
+  P as codeToTokens,
+  ee as codeToTokensBase,
+  ye as codeToTokensWithThemes,
+  bt as createBundledHighlighter,
+  ht as createHighlighterCore,
+  xe as createPositionConverter,
+  ft as createShikiInternal,
+  ct as createShikiInternalSync,
+  St as createSingletonShorthands,
+  Ee as flatTokenVariants,
+  W as getTokenStyleObject,
+  yt as guessEmbeddedLanguages,
+  st as hastToHtml,
+  X as isNoneTheme,
+  Q as isPlainLang,
+  ue as isSpecialLang,
+  ge as isSpecialTheme,
+  ut as makeSingletonHighlighter,
+  he as normalizeGetter,
+  ne as normalizeTheme,
+  D as resolveColorReplacements,
+  V as splitLines,
+  Ne as splitToken,
+  Ie as splitTokens,
+  q as stringifyTokenStyle,
+  Ce as toArray,
+  ze as tokenizeAnsiWithTheme,
+  Ye as tokenizeWithTheme,
+  Ze as tokensToHast,
+  Me as transformerDecorations,
+  at as warnDeprecated
 };
 //# sourceMappingURL=index.esm83.js.map