vue-stream-markdown 0.0.0-alpha.0

package/dist/composables-qhB1h_ed.js

@@ -0,0 +1,1567 @@
+import { computed, defineAsyncComponent, inject, provide, ref, unref, watch, watchEffect } from "vue";
+import { setDefaultProps } from "vue-tippy";
+import "tippy.js/dist/tippy.css";
+import "tippy.js/themes/light.css";
+import "tippy.js/dist/border.css";
+import "tippy.js/dist/svg-arrow.css";
+
+//#region src/composables/use-context.ts
+const CONTEXT_KEY = Symbol("stream-markdown-context");
+function useContext() {
+	const context = injectContext();
+	const isDark = computed(() => unref(context.isDark) ?? false);
+	function provideContext(ctx) {
+		provide(CONTEXT_KEY, {
+			...injectContext(),
+			...ctx
+		});
+	}
+	function injectContext() {
+		return inject(CONTEXT_KEY, {}) || {};
+	}
+	return {
+		context,
+		provideContext,
+		injectContext,
+		isDark,
+		get getContainer() {
+			return context.getContainer || (() => void 0);
+		},
+		get onCopied() {
+			return context.onCopied || (() => {});
+		}
+	};
+}
+
+//#endregion
+//#region src/composables/use-controls.ts
+function useControls(options) {
+	const controls = computed(() => unref(options.controls) ?? true);
+	function isControlEnabled(key) {
+		try {
+			const config = controls.value;
+			if (typeof config === "boolean") return config;
+			const path = key.split(".");
+			let current = config;
+			for (const part of path) {
+				if (current === void 0 || current === null || typeof current !== "object") return true;
+				current = current[part];
+				if (typeof current === "boolean") return current;
+			}
+			return current === true;
+		} catch {
+			return false;
+		}
+	}
+	return { isControlEnabled };
+}
+
+//#endregion
+//#region src/constants/code.ts
+const DEFAULT_LIGHT_THEME = "github-light";
+const DEFAULT_DARK_THEME = "github-dark";
+const LANGUAGE_ALIAS = {};
+const LANGUAGE_EXTENSIONS = {
+	"1c-query": "1cq",
+	"1c": "1c",
+	"文言": "wy",
+	"abap": "abap",
+	"actionscript-3": "as",
+	"ada": "ada",
+	"adoc": "adoc",
+	"angular-html": "html",
+	"angular-ts": "ts",
+	"apache": "conf",
+	"apex": "cls",
+	"apl": "apl",
+	"applescript": "applescript",
+	"ara": "ara",
+	"asciidoc": "adoc",
+	"asm": "asm",
+	"astro": "astro",
+	"awk": "awk",
+	"ballerina": "bal",
+	"bash": "sh",
+	"bat": "bat",
+	"batch": "bat",
+	"be": "be",
+	"beancount": "beancount",
+	"berry": "berry",
+	"bibtex": "bib",
+	"bicep": "bicep",
+	"blade": "blade.php",
+	"bsl": "bsl",
+	"c": "c",
+	"c#": "cs",
+	"c++": "cpp",
+	"cadence": "cdc",
+	"cairo": "cairo",
+	"cdc": "cdc",
+	"clarity": "clar",
+	"clj": "clj",
+	"clojure": "clj",
+	"closure-templates": "soy",
+	"cmake": "cmake",
+	"cmd": "cmd",
+	"cobol": "cob",
+	"codeowners": "CODEOWNERS",
+	"codeql": "ql",
+	"coffee": "coffee",
+	"coffeescript": "coffee",
+	"common-lisp": "lisp",
+	"console": "sh",
+	"coq": "v",
+	"cpp": "cpp",
+	"cql": "cql",
+	"crystal": "cr",
+	"cs": "cs",
+	"csharp": "cs",
+	"css": "css",
+	"csv": "csv",
+	"cue": "cue",
+	"cypher": "cql",
+	"d": "d",
+	"dart": "dart",
+	"dax": "dax",
+	"desktop": "desktop",
+	"diff": "diff",
+	"docker": "dockerfile",
+	"dockerfile": "dockerfile",
+	"dotenv": "env",
+	"dream-maker": "dm",
+	"edge": "edge",
+	"elisp": "el",
+	"elixir": "ex",
+	"elm": "elm",
+	"emacs-lisp": "el",
+	"erb": "erb",
+	"erl": "erl",
+	"erlang": "erl",
+	"f": "f",
+	"f#": "fs",
+	"f03": "f03",
+	"f08": "f08",
+	"f18": "f18",
+	"f77": "f77",
+	"f90": "f90",
+	"f95": "f95",
+	"fennel": "fnl",
+	"fish": "fish",
+	"fluent": "ftl",
+	"for": "for",
+	"fortran-fixed-form": "f",
+	"fortran-free-form": "f90",
+	"fs": "fs",
+	"fsharp": "fs",
+	"fsl": "fsl",
+	"ftl": "ftl",
+	"gdresource": "tres",
+	"gdscript": "gd",
+	"gdshader": "gdshader",
+	"genie": "gs",
+	"gherkin": "feature",
+	"git-commit": "gitcommit",
+	"git-rebase": "gitrebase",
+	"gjs": "js",
+	"gleam": "gleam",
+	"glimmer-js": "js",
+	"glimmer-ts": "ts",
+	"glsl": "glsl",
+	"gnuplot": "plt",
+	"go": "go",
+	"gql": "gql",
+	"graphql": "graphql",
+	"groovy": "groovy",
+	"gts": "gts",
+	"hack": "hack",
+	"haml": "haml",
+	"handlebars": "hbs",
+	"haskell": "hs",
+	"haxe": "hx",
+	"hbs": "hbs",
+	"hcl": "hcl",
+	"hjson": "hjson",
+	"hlsl": "hlsl",
+	"hs": "hs",
+	"html-derivative": "html",
+	"html": "html",
+	"http": "http",
+	"hxml": "hxml",
+	"hy": "hy",
+	"imba": "imba",
+	"ini": "ini",
+	"jade": "jade",
+	"java": "java",
+	"javascript": "js",
+	"jinja": "jinja",
+	"jison": "jison",
+	"jl": "jl",
+	"js": "js",
+	"json": "json",
+	"json5": "json5",
+	"jsonc": "jsonc",
+	"jsonl": "jsonl",
+	"jsonnet": "jsonnet",
+	"jssm": "jssm",
+	"jsx": "jsx",
+	"julia": "jl",
+	"kotlin": "kt",
+	"kql": "kql",
+	"kt": "kt",
+	"kts": "kts",
+	"kusto": "kql",
+	"latex": "tex",
+	"lean": "lean",
+	"lean4": "lean",
+	"less": "less",
+	"liquid": "liquid",
+	"lisp": "lisp",
+	"lit": "lit",
+	"llvm": "ll",
+	"log": "log",
+	"logo": "logo",
+	"lua": "lua",
+	"luau": "luau",
+	"make": "mak",
+	"makefile": "mak",
+	"markdown": "md",
+	"marko": "marko",
+	"matlab": "m",
+	"md": "md",
+	"mdc": "mdc",
+	"mdx": "mdx",
+	"mediawiki": "wiki",
+	"mermaid": "mmd",
+	"mips": "s",
+	"mipsasm": "s",
+	"mmd": "mmd",
+	"mojo": "mojo",
+	"move": "move",
+	"nar": "nar",
+	"narrat": "narrat",
+	"nextflow": "nf",
+	"nf": "nf",
+	"nginx": "conf",
+	"nim": "nim",
+	"nix": "nix",
+	"nu": "nu",
+	"nushell": "nu",
+	"objc": "m",
+	"objective-c": "m",
+	"objective-cpp": "mm",
+	"ocaml": "ml",
+	"pascal": "pas",
+	"perl": "pl",
+	"perl6": "p6",
+	"php": "php",
+	"plsql": "pls",
+	"po": "po",
+	"polar": "polar",
+	"postcss": "pcss",
+	"pot": "pot",
+	"potx": "potx",
+	"powerquery": "pq",
+	"powershell": "ps1",
+	"prisma": "prisma",
+	"prolog": "pl",
+	"properties": "properties",
+	"proto": "proto",
+	"protobuf": "proto",
+	"ps": "ps",
+	"ps1": "ps1",
+	"pug": "pug",
+	"puppet": "pp",
+	"purescript": "purs",
+	"py": "py",
+	"python": "py",
+	"ql": "ql",
+	"qml": "qml",
+	"qmldir": "qmldir",
+	"qss": "qss",
+	"r": "r",
+	"racket": "rkt",
+	"raku": "raku",
+	"razor": "cshtml",
+	"rb": "rb",
+	"reg": "reg",
+	"regex": "regex",
+	"regexp": "regexp",
+	"rel": "rel",
+	"riscv": "s",
+	"rs": "rs",
+	"rst": "rst",
+	"ruby": "rb",
+	"rust": "rs",
+	"sas": "sas",
+	"sass": "sass",
+	"scala": "scala",
+	"scheme": "scm",
+	"scss": "scss",
+	"sdbl": "sdbl",
+	"sh": "sh",
+	"shader": "shader",
+	"shaderlab": "shader",
+	"shell": "sh",
+	"shellscript": "sh",
+	"shellsession": "sh",
+	"smalltalk": "st",
+	"solidity": "sol",
+	"soy": "soy",
+	"sparql": "rq",
+	"spl": "spl",
+	"splunk": "spl",
+	"sql": "sql",
+	"ssh-config": "config",
+	"stata": "do",
+	"styl": "styl",
+	"stylus": "styl",
+	"svelte": "svelte",
+	"swift": "swift",
+	"system-verilog": "sv",
+	"systemd": "service",
+	"talon": "talon",
+	"talonscript": "talon",
+	"tasl": "tasl",
+	"tcl": "tcl",
+	"templ": "templ",
+	"terraform": "tf",
+	"tex": "tex",
+	"tf": "tf",
+	"tfvars": "tfvars",
+	"toml": "toml",
+	"ts-tags": "ts",
+	"ts": "ts",
+	"tsp": "tsp",
+	"tsv": "tsv",
+	"tsx": "tsx",
+	"turtle": "ttl",
+	"twig": "twig",
+	"typ": "typ",
+	"typescript": "ts",
+	"typespec": "tsp",
+	"typst": "typ",
+	"v": "v",
+	"vala": "vala",
+	"vb": "vb",
+	"verilog": "v",
+	"vhdl": "vhdl",
+	"vim": "vim",
+	"viml": "vim",
+	"vimscript": "vim",
+	"vue-html": "html",
+	"vue-vine": "vine",
+	"vue": "vue",
+	"vy": "vy",
+	"vyper": "vy",
+	"wasm": "wasm",
+	"wenyan": "wy",
+	"wgsl": "wgsl",
+	"wiki": "wiki",
+	"wikitext": "wiki",
+	"wit": "wit",
+	"wl": "wl",
+	"wolfram": "wl",
+	"xml": "xml",
+	"xsl": "xsl",
+	"yaml": "yaml",
+	"yml": "yml",
+	"zenscript": "zs",
+	"zig": "zig",
+	"zsh": "zsh"
+};
+const LANGUAGE_ICONS = {
+	"adoc": defineAsyncComponent(() => import("./asciidoc-BabXBDAL.js")),
+	"angular-html": defineAsyncComponent(() => import("./angular-Chs-UKBr.js")),
+	"angular-ts": defineAsyncComponent(() => import("./angular-component-Cc_FANXU.js")),
+	"apache": defineAsyncComponent(() => import("./apache-COYnc6xR.js")),
+	"asciidoc": defineAsyncComponent(() => import("./asciidoc-BabXBDAL.js")),
+	"asm": defineAsyncComponent(() => import("./assembly-CDqKhexW.js")),
+	"astro": defineAsyncComponent(() => import("./astro-C9kftzFG.js")),
+	"bash": defineAsyncComponent(() => import("./bash-Ce4pNIkV.js")),
+	"bat": defineAsyncComponent(() => import("./batch-CHQBRjFL.js")),
+	"batch": defineAsyncComponent(() => import("./batch-CHQBRjFL.js")),
+	"bicep": defineAsyncComponent(() => import("./bicep-8jxWtuBF.js")),
+	"c": defineAsyncComponent(() => import("./c-FBUef746.js")),
+	"c#": defineAsyncComponent(() => import("./csharp-NqZ1vyF9.js")),
+	"c++": defineAsyncComponent(() => import("./cpp-BTKeuyd-.js")),
+	"cjs": defineAsyncComponent(() => import("./javascript-DtnWdTFC.js")),
+	"clj": defineAsyncComponent(() => import("./clojure-BulUroSy.js")),
+	"clojure": defineAsyncComponent(() => import("./clojure-BulUroSy.js")),
+	"cmake": defineAsyncComponent(() => import("./cmake-CW3vz1Mo.js")),
+	"cmd": defineAsyncComponent(() => import("./batch-CHQBRjFL.js")),
+	"cobol": defineAsyncComponent(() => import("./cobol-CIn3oFju.js")),
+	"codeowners": defineAsyncComponent(() => import("./codeowners-CJggXF_b.js")),
+	"coffee": defineAsyncComponent(() => import("./coffeescript-CBrVvzGY.js")),
+	"coffeescript": defineAsyncComponent(() => import("./coffeescript-CBrVvzGY.js")),
+	"cpp": defineAsyncComponent(() => import("./cpp-BTKeuyd-.js")),
+	"crystal": defineAsyncComponent(() => import("./crystal-DyIYvZbm.js")),
+	"cs": defineAsyncComponent(() => import("./csharp-NqZ1vyF9.js")),
+	"csharp": defineAsyncComponent(() => import("./csharp-NqZ1vyF9.js")),
+	"css": defineAsyncComponent(() => import("./css-BpR5Lajb.js")),
+	"csv": defineAsyncComponent(() => import("./csv-eCMFnKKK.js")),
+	"cts": defineAsyncComponent(() => import("./typescript-Bk-pp-cK.js")),
+	"cue": defineAsyncComponent(() => import("./cue-TY97dGOQ.js")),
+	"d": defineAsyncComponent(() => import("./d-NftUsdTd.js")),
+	"dart": defineAsyncComponent(() => import("./dart-DJpwZZbk.js")),
+	"diff": defineAsyncComponent(() => import("./diff-CYRzypaU.js")),
+	"docker": defineAsyncComponent(() => import("./docker-CxHBuukH.js")),
+	"dockerfile": defineAsyncComponent(() => import("./docker-CxHBuukH.js")),
+	"dotenv": defineAsyncComponent(() => import("./env-CDAKsodl.js")),
+	"elixir": defineAsyncComponent(() => import("./elixir-BKSxVc1h.js")),
+	"elm": defineAsyncComponent(() => import("./elm-DScuAf3X.js")),
+	"erb": defineAsyncComponent(() => import("./ruby-B8RxtCzI.js")),
+	"erl": defineAsyncComponent(() => import("./erlang-D2M1ZL3m.js")),
+	"erlang": defineAsyncComponent(() => import("./erlang-D2M1ZL3m.js")),
+	"f": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f#": defineAsyncComponent(() => import("./fsharp-BJz_Jgpl.js")),
+	"f03": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f08": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f18": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f77": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f90": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"f95": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"for": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"fortran-fixed-form": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"fortran-free-form": defineAsyncComponent(() => import("./fortran-CORyQ0wt.js")),
+	"fs": defineAsyncComponent(() => import("./fsharp-BJz_Jgpl.js")),
+	"fsharp": defineAsyncComponent(() => import("./fsharp-BJz_Jgpl.js")),
+	"git-commit": defineAsyncComponent(() => import("./git-DgrlTr1E.js")),
+	"git-rebase": defineAsyncComponent(() => import("./git-DgrlTr1E.js")),
+	"gleam": defineAsyncComponent(() => import("./gleam-t_xad9Kw.js")),
+	"go": defineAsyncComponent(() => import("./go-Cvlh1xtL.js")),
+	"gql": defineAsyncComponent(() => import("./graphql-ApIm0mDD.js")),
+	"graphql": defineAsyncComponent(() => import("./graphql-ApIm0mDD.js")),
+	"groovy": defineAsyncComponent(() => import("./groovy-CaLnK8PV.js")),
+	"haml": defineAsyncComponent(() => import("./haml-MwijEO_6.js")),
+	"handlebars": defineAsyncComponent(() => import("./handlebars-CKdUPI9h.js")),
+	"haskell": defineAsyncComponent(() => import("./haskell-NPOXEnck.js")),
+	"haxe": defineAsyncComponent(() => import("./haxe-DyKBMsDE.js")),
+	"hbs": defineAsyncComponent(() => import("./handlebars-CKdUPI9h.js")),
+	"hs": defineAsyncComponent(() => import("./haskell-NPOXEnck.js")),
+	"html": defineAsyncComponent(() => import("./html-CMgES1dE.js")),
+	"http": defineAsyncComponent(() => import("./http-B9FFNmUr.js")),
+	"jade": defineAsyncComponent(() => import("./pug-B1-IC-Tc.js")),
+	"java": defineAsyncComponent(() => import("./java-iU-L9wJz.js")),
+	"javascript": defineAsyncComponent(() => import("./javascript-DtnWdTFC.js")),
+	"jinja": defineAsyncComponent(() => import("./jinja-CoWszo_D.js")),
+	"jl": defineAsyncComponent(() => import("./julia-DG2BCBLx.js")),
+	"js": defineAsyncComponent(() => import("./javascript-DtnWdTFC.js")),
+	"json": defineAsyncComponent(() => import("./json-C80qKCnh.js")),
+	"json5": defineAsyncComponent(() => import("./json-C80qKCnh.js")),
+	"jsonc": defineAsyncComponent(() => import("./json-C80qKCnh.js")),
+	"jsonl": defineAsyncComponent(() => import("./json-C80qKCnh.js")),
+	"jsx": defineAsyncComponent(() => import("./javascript-DtnWdTFC.js")),
+	"julia": defineAsyncComponent(() => import("./julia-DG2BCBLx.js")),
+	"kdl": defineAsyncComponent(() => import("./kdl-7twRfIlJ.js")),
+	"kotlin": defineAsyncComponent(() => import("./kotlin-BjrOgP7R.js")),
+	"kt": defineAsyncComponent(() => import("./kotlin-BjrOgP7R.js")),
+	"kts": defineAsyncComponent(() => import("./kotlin-BjrOgP7R.js")),
+	"latex": defineAsyncComponent(() => import("./latex-DIQfUvG8.js")),
+	"less": defineAsyncComponent(() => import("./less-BJ1yEAWt.js")),
+	"liquid": defineAsyncComponent(() => import("./liquid-BqKFZ1wQ.js")),
+	"lisp": defineAsyncComponent(() => import("./lisp-oekhB2ti.js")),
+	"log": defineAsyncComponent(() => import("./log-D1XEqR9q.js")),
+	"lua": defineAsyncComponent(() => import("./lua-C5Q97-1D.js")),
+	"luau": defineAsyncComponent(() => import("./luau-BT8KwqZ2.js")),
+	"make": defineAsyncComponent(() => import("./makefile-B4a0ciG4.js")),
+	"makefile": defineAsyncComponent(() => import("./makefile-B4a0ciG4.js")),
+	"markdown": defineAsyncComponent(() => import("./markdown-DvNyKsiJ.js")),
+	"marko": defineAsyncComponent(() => import("./marko-BzsIf6bg.js")),
+	"matlab": defineAsyncComponent(() => import("./matlab-cMBkmDhQ.js")),
+	"md": defineAsyncComponent(() => import("./markdown-DvNyKsiJ.js")),
+	"mdc": defineAsyncComponent(() => import("./markdown-DvNyKsiJ.js")),
+	"mdx": defineAsyncComponent(() => import("./markdown-DvNyKsiJ.js")),
+	"mermaid": defineAsyncComponent(() => import("./mermaid-8JIH2gkQ.js")),
+	"mjs": defineAsyncComponent(() => import("./javascript-DtnWdTFC.js")),
+	"mmd": defineAsyncComponent(() => import("./mermaid-8JIH2gkQ.js")),
+	"mts": defineAsyncComponent(() => import("./typescript-Bk-pp-cK.js")),
+	"nextflow": defineAsyncComponent(() => import("./nextflow-DNmqU1xg.js")),
+	"nf": defineAsyncComponent(() => import("./nextflow-DNmqU1xg.js")),
+	"nginx": defineAsyncComponent(() => import("./nginx-DDfYF_rj.js")),
+	"nim": defineAsyncComponent(() => import("./nim-D9xEmy4k.js")),
+	"nix": defineAsyncComponent(() => import("./nix-BV1Deshw.js")),
+	"ocaml": defineAsyncComponent(() => import("./ocaml-BkFn4LL3.js")),
+	"perl": defineAsyncComponent(() => import("./perl-BytUHDE7.js")),
+	"php": defineAsyncComponent(() => import("./php-BImJJtNM.js")),
+	"postcss": defineAsyncComponent(() => import("./postcss-CrZ9_0sT.js")),
+	"powershell": defineAsyncComponent(() => import("./powershell-DYSGu7TM.js")),
+	"prisma": defineAsyncComponent(() => import("./prisma-BhRvcOFY.js")),
+	"prolog": defineAsyncComponent(() => import("./prolog-DuaCKek_.js")),
+	"properties": defineAsyncComponent(() => import("./properties-BbIJwuP-.js")),
+	"proto": defineAsyncComponent(() => import("./proto-CE0aVW11.js")),
+	"protobuf": defineAsyncComponent(() => import("./proto-CE0aVW11.js")),
+	"ps": defineAsyncComponent(() => import("./powershell-DYSGu7TM.js")),
+	"ps1": defineAsyncComponent(() => import("./powershell-DYSGu7TM.js")),
+	"pug": defineAsyncComponent(() => import("./pug-B1-IC-Tc.js")),
+	"puppet": defineAsyncComponent(() => import("./puppet-8nYquiMG.js")),
+	"py": defineAsyncComponent(() => import("./python-DhRyfBrD.js")),
+	"python": defineAsyncComponent(() => import("./python-DhRyfBrD.js")),
+	"r": defineAsyncComponent(() => import("./r-Cjje17IA.js")),
+	"racket": defineAsyncComponent(() => import("./racket-Dx0gMnpg.js")),
+	"razor": defineAsyncComponent(() => import("./razor-DPht_bdD.js")),
+	"rb": defineAsyncComponent(() => import("./ruby-B8RxtCzI.js")),
+	"rs": defineAsyncComponent(() => import("./rust-Cjtli6yf.js")),
+	"ruby": defineAsyncComponent(() => import("./ruby-B8RxtCzI.js")),
+	"rust": defineAsyncComponent(() => import("./rust-Cjtli6yf.js")),
+	"sass": defineAsyncComponent(() => import("./sass-Dv3DMzjs.js")),
+	"scala": defineAsyncComponent(() => import("./scala-B7bZGKXq.js")),
+	"scheme": defineAsyncComponent(() => import("./scheme-B2PsEdVN.js")),
+	"scss": defineAsyncComponent(() => import("./sass-Dv3DMzjs.js")),
+	"sh": defineAsyncComponent(() => import("./bash-Ce4pNIkV.js")),
+	"shader": defineAsyncComponent(() => import("./shader-BZzu3zGr.js")),
+	"shell": defineAsyncComponent(() => import("./bash-Ce4pNIkV.js")),
+	"shellscript": defineAsyncComponent(() => import("./bash-Ce4pNIkV.js")),
+	"solidity": defineAsyncComponent(() => import("./solidity-CLieFYpL.js")),
+	"sql": defineAsyncComponent(() => import("./database-aZwE71Px.js")),
+	"stata": defineAsyncComponent(() => import("./stata-C0yUiO47.js")),
+	"styl": defineAsyncComponent(() => import("./sass-Dv3DMzjs.js")),
+	"stylus": defineAsyncComponent(() => import("./sass-Dv3DMzjs.js")),
+	"svelte": defineAsyncComponent(() => import("./svelte-rtF4yNGL.js")),
+	"swift": defineAsyncComponent(() => import("./swift-CzvYoIM0.js")),
+	"terraform": defineAsyncComponent(() => import("./terraform-CD_BZGb-.js")),
+	"tex": defineAsyncComponent(() => import("./latex-DIQfUvG8.js")),
+	"text": defineAsyncComponent(() => import("./text-D1-vbZ7l.js")),
+	"tf": defineAsyncComponent(() => import("./terraform-CD_BZGb-.js")),
+	"tfvars": defineAsyncComponent(() => import("./terraform-CD_BZGb-.js")),
+	"toml": defineAsyncComponent(() => import("./toml-C6jUF0Xd.js")),
+	"ts": defineAsyncComponent(() => import("./typescript-Bk-pp-cK.js")),
+	"tsv": defineAsyncComponent(() => import("./csv-eCMFnKKK.js")),
+	"tsx": defineAsyncComponent(() => import("./typescript-Bk-pp-cK.js")),
+	"twig": defineAsyncComponent(() => import("./twig-C4dfP84J.js")),
+	"typ": defineAsyncComponent(() => import("./typst-DPCpaVSH.js")),
+	"typescript": defineAsyncComponent(() => import("./typescript-Bk-pp-cK.js")),
+	"typst": defineAsyncComponent(() => import("./typst-DPCpaVSH.js")),
+	"v": defineAsyncComponent(() => import("./v-nRGMJ2Ki.js")),
+	"vala": defineAsyncComponent(() => import("./vala-B78bKcY0.js")),
+	"verilog": defineAsyncComponent(() => import("./verilog-CRpkl76S.js")),
+	"vim": defineAsyncComponent(() => import("./vim-DpKnut7b.js")),
+	"viml": defineAsyncComponent(() => import("./vim-DpKnut7b.js")),
+	"vimscript": defineAsyncComponent(() => import("./vim-DpKnut7b.js")),
+	"vue-html": defineAsyncComponent(() => import("./vue-D5eadhjo.js")),
+	"vue-vine": defineAsyncComponent(() => import("./vue-D5eadhjo.js")),
+	"vue": defineAsyncComponent(() => import("./vue-D5eadhjo.js")),
+	"xml": defineAsyncComponent(() => import("./xml-Dvx5F-hl.js")),
+	"xsl": defineAsyncComponent(() => import("./xml-Dvx5F-hl.js")),
+	"yaml": defineAsyncComponent(() => import("./yaml-n1S8nAOh.js")),
+	"yml": defineAsyncComponent(() => import("./yaml-n1S8nAOh.js")),
+	"zig": defineAsyncComponent(() => import("./zig-R-iFzxfW.js")),
+	"zsh": defineAsyncComponent(() => import("./bash-Ce4pNIkV.js"))
+};
+
+//#endregion
+//#region src/constants/harden.ts
+const DEFAULT_HARDEN_OPTIONS = {
+	allowedLinkPrefixes: ["*"],
+	allowedImagePrefixes: ["*"],
+	allowedProtocols: ["*"],
+	allowDataImages: true
+};
+
+//#endregion
+//#region src/constants/icons.ts
+const ICONS = {
+	check: defineAsyncComponent(() => import("./check-C4xOk8um.js")),
+	code: defineAsyncComponent(() => import("./code-D8LSp8rK.js")),
+	collapse: defineAsyncComponent(() => import("./chevron-down-cnOJ4h1g.js")),
+	copy: defineAsyncComponent(() => import("./copy-Cabve0xf.js")),
+	download: defineAsyncComponent(() => import("./download-Bnn7rtYw.js")),
+	error: defineAsyncComponent(() => import("./circle-alert-CLX-h5rZ.js")),
+	image: defineAsyncComponent(() => import("./image-CMZAakWu.js")),
+	link: defineAsyncComponent(() => import("./link-DeV4CQOB.js")),
+	maximize: defineAsyncComponent(() => import("./maximize-4PIqBONS.js")),
+	mermaid: defineAsyncComponent(() => import("./mermaid-8JIH2gkQ.js")),
+	minimize: defineAsyncComponent(() => import("./minimize-BJ8htyDF.js")),
+	preview: defineAsyncComponent(() => import("./eye-CdeX8PhP.js")),
+	zoomIn: defineAsyncComponent(() => import("./zoomIn-CEukuh3x.js")),
+	zoomOut: defineAsyncComponent(() => import("./zoomOut-qlzQyQli.js"))
+};
+
+//#endregion
+//#region src/utils/harden.ts
+const safeProtocols = new Set([
+	"https:",
+	"http:",
+	"irc:",
+	"ircs:",
+	"mailto:",
+	"xmpp:",
+	"blob:"
+]);
+const blockedProtocols = new Set([
+	"javascript:",
+	"data:",
+	"file:",
+	"vbscript:"
+]);
+function parseUrl(url, defaultOrigin) {
+	if (typeof url !== "string") return null;
+	try {
+		return new URL(url);
+	} catch {
+		if (defaultOrigin) try {
+			return new URL(url, defaultOrigin);
+		} catch {
+			return null;
+		}
+		return null;
+	}
+}
+function isPathRelativeUrl(url) {
+	if (typeof url !== "string") return false;
+	return url.startsWith("/");
+}
+function transformUrl(url, allowedPrefixes, defaultOrigin, allowDataImages = false, isImage = false, allowedProtocols = []) {
+	if (!url) return null;
+	if (typeof url === "string" && url.startsWith("#") && !isImage) try {
+		if (new URL(url, "http://example.com").hash === url) return url;
+	} catch {}
+	if (typeof url === "string" && url.startsWith("data:")) {
+		if (isImage && allowDataImages && url.startsWith("data:image/")) return url;
+		return null;
+	}
+	if (typeof url === "string" && url.startsWith("blob:")) {
+		try {
+			if (new URL(url).protocol === "blob:" && url.length > 5) {
+				const afterProtocol = url.substring(5);
+				if (afterProtocol && afterProtocol.length > 0 && afterProtocol !== "invalid") return url;
+			}
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	const parsedUrl = parseUrl(url, defaultOrigin);
+	if (!parsedUrl) return null;
+	if (blockedProtocols.has(parsedUrl.protocol)) return null;
+	if (!(safeProtocols.has(parsedUrl.protocol) || allowedProtocols.includes(parsedUrl.protocol) || allowedProtocols.includes("*"))) return null;
+	if (parsedUrl.protocol === "mailto:" || !parsedUrl.protocol.match(/^https?:$/)) return parsedUrl.href;
+	const inputWasRelative = isPathRelativeUrl(url);
+	if (parsedUrl && allowedPrefixes.some((prefix) => {
+		const parsedPrefix = parseUrl(prefix, defaultOrigin);
+		if (!parsedPrefix) return false;
+		if (parsedPrefix.origin !== parsedUrl.origin) return false;
+		return parsedUrl.href.startsWith(parsedPrefix.href);
+	})) {
+		if (inputWasRelative) return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+		return parsedUrl.href;
+	}
+	if (allowedPrefixes.includes("*")) {
+		if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") return null;
+		if (inputWasRelative) return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+		return parsedUrl.href;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/utils/helper.ts
+function flow(fns) {
+	return (input) => fns.reduce((acc, fn) => fn(acc), input);
+}
+function save(filename, content, mimeType) {
+	const blob = typeof content === "string" ? new Blob([content], { type: mimeType }) : content;
+	const url = URL.createObjectURL(blob);
+	const a = document.createElement("a");
+	a.href = url;
+	a.download = filename;
+	document.body.appendChild(a);
+	a.click();
+	document.body.removeChild(a);
+	URL.revokeObjectURL(url);
+}
+function svgToPngBlob(svgString, options) {
+	const scale = (options === null || options === void 0 ? void 0 : options.scale) ?? 5;
+	return new Promise((resolve, reject) => {
+		const encoded = `data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(svgString)))}`;
+		const img = new Image();
+		img.crossOrigin = "anonymous";
+		img.onload = () => {
+			const canvas = document.createElement("canvas");
+			const w = img.width * scale;
+			const h$1 = img.height * scale;
+			canvas.width = w;
+			canvas.height = h$1;
+			const ctx = canvas.getContext("2d");
+			if (!ctx) {
+				reject(/* @__PURE__ */ new Error("Failed to create 2D canvas context for PNG export"));
+				return;
+			}
+			ctx.drawImage(img, 0, 0, w, h$1);
+			canvas.toBlob((blob) => {
+				if (!blob) {
+					reject(/* @__PURE__ */ new Error("Failed to create PNG blob"));
+					return;
+				}
+				resolve(blob);
+			}, "image/png");
+		};
+		img.onerror = () => reject(/* @__PURE__ */ new Error("Failed to load SVG image"));
+		img.src = encoded;
+	});
+}
+
+//#endregion
+//#region src/utils/module.ts
+async function hasShiki() {
+	try {
+		await import("shiki");
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function hasMermaid() {
+	try {
+		await import("mermaid");
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function hasKatex() {
+	try {
+		await import("katex");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/parser.ts
+function findLastLeafNode(nodes) {
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const node = nodes[i];
+		const nodeWithChildren = node;
+		if (nodeWithChildren.children && nodeWithChildren.children.length > 0) {
+			const found = findLastLeafNode(nodeWithChildren.children);
+			if (found) return found;
+			continue;
+		}
+		return node;
+	}
+	return null;
+}
+function findNodeParent(targetNode, nodes, parent) {
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		if (nodes[i] === targetNode && parent) return {
+			parent,
+			index: i
+		};
+		const node = nodes[i];
+		if (node.children) {
+			const result = findNodeParent(targetNode, node.children, node);
+			if (result) return result;
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/utils/table.ts
+function extractTableDataFromElement(tableElement) {
+	const headers = [];
+	const rows = [];
+	const headerCells = Array.from(tableElement.querySelectorAll("thead th"));
+	for (const cell of headerCells) {
+		var _cell$textContent;
+		headers.push(((_cell$textContent = cell.textContent) === null || _cell$textContent === void 0 ? void 0 : _cell$textContent.trim()) || "");
+	}
+	const bodyRows = Array.from(tableElement.querySelectorAll("tbody tr"));
+	for (const row of bodyRows) {
+		const rowData = [];
+		const cells = Array.from(row.querySelectorAll("td"));
+		for (const cell of cells) {
+			var _cell$textContent2;
+			rowData.push(((_cell$textContent2 = cell.textContent) === null || _cell$textContent2 === void 0 ? void 0 : _cell$textContent2.trim()) || "");
+		}
+		rows.push(rowData);
+	}
+	return {
+		headers,
+		rows
+	};
+}
+function tableDataToCSV(data) {
+	const { headers, rows } = data;
+	const escapeCSV = (value) => {
+		let needsEscaping = false;
+		let hasQuote = false;
+		for (let i = 0; i < value.length; i += 1) {
+			const char = value[i];
+			if (char === "\"") {
+				needsEscaping = true;
+				hasQuote = true;
+				break;
+			}
+			if (char === "," || char === "\n") needsEscaping = true;
+		}
+		if (!needsEscaping) return value;
+		if (hasQuote) return `"${value.replace(/"/g, "\"\"")}"`;
+		return `"${value}"`;
+	};
+	const totalRows = headers.length > 0 ? rows.length + 1 : rows.length;
+	const csvRows = Array.from({ length: totalRows });
+	let rowIndex = 0;
+	if (headers.length > 0) {
+		csvRows[rowIndex] = headers.map(escapeCSV).join(",");
+		rowIndex += 1;
+	}
+	for (const row of rows) {
+		csvRows[rowIndex] = row.map(escapeCSV).join(",");
+		rowIndex += 1;
+	}
+	return csvRows.join("\n");
+}
+function tableDataToTSV(data) {
+	const { headers, rows } = data;
+	const escapeTSV = (value) => {
+		let needsEscaping = false;
+		for (let i = 0; i < value.length; i += 1) {
+			const char = value[i];
+			if (char === "	" || char === "\n" || char === "\r") {
+				needsEscaping = true;
+				break;
+			}
+		}
+		if (!needsEscaping) return value;
+		const parts = [];
+		for (let i = 0; i < value.length; i += 1) {
+			const char = value[i];
+			if (char === "	") parts.push("\\t");
+			else if (char === "\n") parts.push("\\n");
+			else if (char === "\r") parts.push("\\r");
+			else parts.push(char);
+		}
+		return parts.join("");
+	};
+	const totalRows = headers.length > 0 ? rows.length + 1 : rows.length;
+	const tsvRows = Array.from({ length: totalRows });
+	let rowIndex = 0;
+	if (headers.length > 0) {
+		tsvRows[rowIndex] = headers.map(escapeTSV).join("	");
+		rowIndex += 1;
+	}
+	for (const row of rows) {
+		tsvRows[rowIndex] = row.map(escapeTSV).join("	");
+		rowIndex += 1;
+	}
+	return tsvRows.join("\n");
+}
+function escapeMarkdownTableCell(cell) {
+	let needsEscaping = false;
+	for (let i = 0; i < cell.length; i += 1) {
+		const char = cell[i];
+		if (char === "\\" || char === "|") {
+			needsEscaping = true;
+			break;
+		}
+	}
+	if (!needsEscaping) return cell;
+	const parts = [];
+	for (let i = 0; i < cell.length; i += 1) {
+		const char = cell[i];
+		if (char === "\\") parts.push("\\\\");
+		else if (char === "|") parts.push("\\|");
+		else parts.push(char);
+	}
+	return parts.join("");
+}
+function tableDataToMarkdown(data) {
+	const { headers, rows } = data;
+	if (headers.length === 0) return "";
+	const markdownRows = Array.from({ length: rows.length + 2 });
+	let rowIndex = 0;
+	markdownRows[rowIndex] = `| ${headers.map((h$1) => escapeMarkdownTableCell(h$1)).join(" | ")} |`;
+	rowIndex += 1;
+	const separatorParts = Array.from({ length: headers.length });
+	for (let i = 0; i < headers.length; i += 1) separatorParts[i] = "---";
+	markdownRows[rowIndex] = `| ${separatorParts.join(" | ")} |`;
+	rowIndex += 1;
+	for (const row of rows) if (row.length < headers.length) {
+		const paddedRow = Array.from({ length: headers.length });
+		for (let i = 0; i < headers.length; i += 1) paddedRow[i] = i < row.length ? escapeMarkdownTableCell(row[i]) : "";
+		markdownRows[rowIndex] = `| ${paddedRow.join(" | ")} |`;
+		rowIndex += 1;
+	} else {
+		markdownRows[rowIndex] = `| ${row.map((cell) => escapeMarkdownTableCell(cell)).join(" | ")} |`;
+		rowIndex += 1;
+	}
+	return markdownRows.join("\n");
+}
+
+//#endregion
+//#region src/composables/use-harden-sanitizers.ts
+function useHardenSanitizers(options) {
+	const hardenOptions = computed(() => unref(options.hardenOptions) ?? DEFAULT_HARDEN_OPTIONS);
+	const loading = computed(() => unref(options.loading) ?? false);
+	const allowedLinkPrefixes = computed(() => hardenOptions.value.allowedLinkPrefixes ?? ["*"]);
+	const allowedImagePrefixes = computed(() => hardenOptions.value.allowedImagePrefixes ?? ["*"]);
+	const allowedProtocols = computed(() => hardenOptions.value.allowedProtocols ?? ["*"]);
+	const allowDataImages = computed(() => hardenOptions.value.allowDataImages ?? true);
+	const defaultOrigin = computed(() => hardenOptions.value.defaultOrigin ?? "");
+	const isImage = computed(() => unref(options.isImage) ?? false);
+	const url = computed(() => unref(options.url) ?? "");
+	const transformedUrl = computed(() => transformHardenUrl(url.value));
+	const isHardenUrl = computed(() => transformedUrl.value === null);
+	function transformHardenUrl(url$1) {
+		if (!url$1 || loading.value) return url$1;
+		return transformUrl(url$1, isImage.value ? allowedImagePrefixes.value : allowedLinkPrefixes.value, defaultOrigin.value, allowDataImages.value, isImage.value, allowedProtocols.value);
+	}
+	return {
+		hardenOptions,
+		transformHardenUrl,
+		transformedUrl,
+		isHardenUrl
+	};
+}
+
+//#endregion
+//#region src/composables/use-hsl-theme.ts
+function useHslTheme() {}
+
+//#endregion
+//#region src/locales/index.ts
+const SUPPORT_LANGUAGES = ["en-US", "zh-CN"];
+const localesGlob = {
+	"./en-US.json": () => import("./en-US-Bfc50l3I.js"),
+	"./zh-CN.json": () => import("./zh-CN-CL1XGe0H.js")
+};
+const localeMessages = ref();
+const currentLocale = ref("en-US");
+async function loadLocaleMessages(language) {
+	const load = async (language$1) => {
+		localeMessages.value = await localesGlob[`./${language$1}.json`]();
+		currentLocale.value = language$1;
+	};
+	try {
+		if (typeof language === "string") await load(language);
+		else localeMessages.value = language;
+	} catch {
+		await load("en-US");
+	}
+}
+loadLocaleMessages("en-US");
+
+//#endregion
+//#region src/composables/use-i18n.ts
+function useI18n() {
+	function getI18nText(key) {
+		try {
+			const messages = localeMessages.value;
+			if (!messages) return key;
+			const result = key.split(".").reduce((obj, k) => {
+				if (obj && typeof obj === "object" && k in obj) return obj[k];
+			}, messages);
+			return typeof result === "string" ? result : key;
+		} catch {
+			return key;
+		}
+	}
+	return { t: getI18nText };
+}
+
+//#endregion
+//#region src/composables/use-katex.ts
+let existingKatex = false;
+function useKatex() {
+	const installed = ref(false);
+	async function render(code, options = {}) {
+		const { renderToString } = await import("katex");
+		try {
+			return { html: renderToString(code, {
+				output: "html",
+				strict: "ignore",
+				...options
+			}) };
+		} catch (error) {
+			return { error: error.message };
+		}
+	}
+	async function preload() {
+		if (await hasKatex()) import("katex/dist/katex.min.css");
+	}
+	function dispose() {}
+	(async () => {
+		if (existingKatex === true) {
+			installed.value = true;
+			return;
+		}
+		installed.value = await hasKatex();
+		existingKatex = installed.value;
+	})();
+	return {
+		installed,
+		render,
+		preload,
+		dispose
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+
+//#endregion
+//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
+let _Symbol$iterator;
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function randomStr(size = 16, dict = urlAlphabet) {
+	let id = "";
+	let i = size;
+	const len = dict.length;
+	while (i--) id += dict[Math.random() * len | 0];
+	return id;
+}
+var Node = class {
+	constructor(value) {
+		_defineProperty(this, "value", void 0);
+		_defineProperty(this, "next", void 0);
+		this.value = value;
+	}
+};
+var _head = /* @__PURE__ */ new WeakMap();
+var _tail = /* @__PURE__ */ new WeakMap();
+var _size = /* @__PURE__ */ new WeakMap();
+_Symbol$iterator = Symbol.iterator;
+var Queue = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _head, void 0);
+		_classPrivateFieldInitSpec(this, _tail, void 0);
+		_classPrivateFieldInitSpec(this, _size, void 0);
+		this.clear();
+	}
+	enqueue(value) {
+		var _this$size;
+		const node = new Node(value);
+		if (_classPrivateFieldGet2(_head, this)) {
+			_classPrivateFieldGet2(_tail, this).next = node;
+			_classPrivateFieldSet2(_tail, this, node);
+		} else {
+			_classPrivateFieldSet2(_head, this, node);
+			_classPrivateFieldSet2(_tail, this, node);
+		}
+		_classPrivateFieldSet2(_size, this, (_this$size = _classPrivateFieldGet2(_size, this), _this$size++, _this$size));
+	}
+	dequeue() {
+		var _this$size3;
+		const current = _classPrivateFieldGet2(_head, this);
+		if (!current) return;
+		_classPrivateFieldSet2(_head, this, _classPrivateFieldGet2(_head, this).next);
+		_classPrivateFieldSet2(_size, this, (_this$size3 = _classPrivateFieldGet2(_size, this), _this$size3--, _this$size3));
+		return current.value;
+	}
+	peek() {
+		if (!_classPrivateFieldGet2(_head, this)) return;
+		return _classPrivateFieldGet2(_head, this).value;
+	}
+	clear() {
+		_classPrivateFieldSet2(_head, this, void 0);
+		_classPrivateFieldSet2(_tail, this, void 0);
+		_classPrivateFieldSet2(_size, this, 0);
+	}
+	get size() {
+		return _classPrivateFieldGet2(_size, this);
+	}
+	*[_Symbol$iterator]() {
+		let current = _classPrivateFieldGet2(_head, this);
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (_classPrivateFieldGet2(_head, this)) yield this.dequeue();
+	}
+};
+/**
+* Throttle execution of a function. Especially useful for rate limiting
+* execution of handlers on events like resize and scroll.
+*
+* @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+*                                            are most useful.
+* @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+*                                            as-is, to `callback` when the throttled-function is executed.
+* @param {object} [options] -              An object to configure options.
+* @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+*                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+*                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+*                                            `delay` milliseconds, the internal counter is reset).
+* @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+*                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+*                                            callback will never executed if both noLeading = true and noTrailing = true.
+* @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+*                                            false (at end), schedule `callback` to execute after `delay` ms.
+*
+* @returns {Function} A new, throttled, function.
+*/
+function throttle$1(delay, callback, options) {
+	var _ref = options || {}, _ref$noTrailing = _ref.noTrailing, noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing, _ref$noLeading = _ref.noLeading, noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading, _ref$debounceMode = _ref.debounceMode, debounceMode = _ref$debounceMode === void 0 ? void 0 : _ref$debounceMode;
+	var timeoutID;
+	var cancelled = false;
+	var lastExec = 0;
+	function clearExistingTimeout() {
+		if (timeoutID) clearTimeout(timeoutID);
+	}
+	function cancel(options$1) {
+		var _ref2$upcomingOnly = (options$1 || {}).upcomingOnly, upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+		clearExistingTimeout();
+		cancelled = !upcomingOnly;
+	}
+	function wrapper() {
+		for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) arguments_[_key] = arguments[_key];
+		var self = this;
+		var elapsed = Date.now() - lastExec;
+		if (cancelled) return;
+		function exec() {
+			lastExec = Date.now();
+			callback.apply(self, arguments_);
+		}
+		function clear() {
+			timeoutID = void 0;
+		}
+		if (!noLeading && debounceMode && !timeoutID) exec();
+		clearExistingTimeout();
+		if (debounceMode === void 0 && elapsed > delay) if (noLeading) {
+			lastExec = Date.now();
+			if (!noTrailing) timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+		} else exec();
+		else if (noTrailing !== true) timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === void 0 ? delay - elapsed : delay);
+	}
+	wrapper.cancel = cancel;
+	return wrapper;
+}
+function throttle(...args) {
+	return throttle$1(...args);
+}
+
+//#endregion
+//#region src/composables/use-math-renderer.ts
+function useMathRenderer(options) {
+	const { installed, render: renderKatex } = useKatex();
+	const renderFlag = ref(false);
+	const renderingCode = ref("");
+	const html = ref("");
+	const errorMessage = ref("");
+	const node = computed(() => unref(options.node));
+	const katexOptions = computed(() => {
+		var _unref;
+		return ((_unref = unref(options.katexOptions)) === null || _unref === void 0 ? void 0 : _unref.config) ?? {};
+	});
+	const throttleTime = computed(() => unref(options.throttle) ?? 150);
+	const code = computed(() => node.value.value);
+	const loading = computed(() => node.value.loading);
+	const isDisplayMode = computed(() => node.value.type !== "inlineMath");
+	const error = computed(() => {
+		if (!installed.value) return true;
+		if (errorMessage.value && renderFlag.value && renderingCode.value === code.value) return true;
+		return false;
+	});
+	watch(() => [code.value, loading.value], throttle(throttleTime, async () => {
+		const { html: data, error: error$1 } = await renderKatex(code.value, {
+			...katexOptions,
+			displayMode: isDisplayMode.value
+		});
+		renderFlag.value = true;
+		if (data) {
+			html.value = data;
+			errorMessage.value = "";
+			return;
+		}
+		if (error$1) errorMessage.value = error$1;
+		else errorMessage.value = "";
+	}), { immediate: true });
+	return {
+		html,
+		error,
+		errorMessage
+	};
+}
+
+//#endregion
+//#region src/composables/use-mermaid.ts
+let mermaid = null;
+function useMermaid(options) {
+	const installed = ref(false);
+	const mermaidConfig = computed(() => {
+		var _unref;
+		return ((_unref = unref(options === null || options === void 0 ? void 0 : options.mermaidOptions)) === null || _unref === void 0 ? void 0 : _unref.config) ?? {};
+	});
+	const mermaidTheme = computed(() => {
+		var _unref2;
+		return ((_unref2 = unref(options === null || options === void 0 ? void 0 : options.mermaidOptions)) === null || _unref2 === void 0 ? void 0 : _unref2.theme) ?? ["neutral", "dark"];
+	});
+	const isDark = computed(() => unref(options === null || options === void 0 ? void 0 : options.isDark) ?? false);
+	const lightTheme = computed(() => mermaidTheme.value[0] ?? "neutral");
+	const darkTheme = computed(() => mermaidTheme.value[1] ?? "dark");
+	const theme = computed(() => isDark.value ? darkTheme.value : lightTheme.value);
+	const chart = ref("");
+	async function getMermaid() {
+		if (mermaid) return mermaid;
+		const { default: module } = await import("mermaid");
+		module.initialize({
+			startOnLoad: false,
+			securityLevel: "loose",
+			...mermaidConfig.value
+		});
+		mermaid = module;
+		return mermaid;
+	}
+	function wrapThemeCode(code) {
+		if (code.startsWith("%%{")) return code;
+		return `${`%%{init: {"theme": "${theme.value}"}}%%\n`}${code}`;
+	}
+	async function parseMermaid(code) {
+		try {
+			const mermaid$1 = await getMermaid();
+			chart.value = wrapThemeCode(code);
+			await mermaid$1.parse(chart.value);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async function renderMermaid(code) {
+		if (!await parseMermaid(code)) return null;
+		const id = `mermaid-${randomStr()}`;
+		try {
+			return (await (await getMermaid()).render(id, wrapThemeCode(code))).svg;
+		} catch {
+			const element = document.getElementById(`d${id}`);
+			if (element) element.remove();
+			return null;
+		}
+	}
+	async function saveMermaid(format, code = chart.value, onError) {
+		try {
+			const svg = await renderMermaid(code);
+			if (!svg) {
+				onError === null || onError === void 0 || onError(/* @__PURE__ */ new Error("SVG not found. Please wait for the diagram to render."));
+				return;
+			}
+			if (format === "svg") save("diagram.svg", svg, "image/svg+xml");
+			if (format === "png") save("diagram.png", await svgToPngBlob(svg), "image/png");
+		} catch (error) {
+			onError === null || onError === void 0 || onError(error);
+		}
+	}
+	async function preload() {
+		if (mermaid) return;
+		installed.value = await hasMermaid();
+		if (installed.value) await getMermaid();
+	}
+	function dispose() {
+		chart.value = "";
+	}
+	(async () => {
+		if (mermaid) {
+			installed.value = true;
+			return;
+		}
+		installed.value = await hasMermaid();
+	})();
+	return {
+		installed,
+		getMermaid,
+		parseMermaid,
+		renderMermaid,
+		saveMermaid,
+		preload,
+		dispose
+	};
+}
+
+//#endregion
+//#region src/composables/use-shiki.ts
+let highlighter = null;
+function useShiki(options) {
+	const installed = ref(false);
+	const lang = computed(() => unref(options === null || options === void 0 ? void 0 : options.lang) ?? "plaintext");
+	const shikiTheme = computed(() => {
+		var _unref;
+		return ((_unref = unref(options === null || options === void 0 ? void 0 : options.shikiOptions)) === null || _unref === void 0 ? void 0 : _unref.theme) ?? [DEFAULT_LIGHT_THEME, DEFAULT_DARK_THEME];
+	});
+	const lightTheme = computed(() => shikiTheme.value[0] ?? DEFAULT_LIGHT_THEME);
+	const darkTheme = computed(() => shikiTheme.value[1] ?? DEFAULT_DARK_THEME);
+	const langAlias = computed(() => {
+		var _unref2;
+		return ((_unref2 = unref(options === null || options === void 0 ? void 0 : options.shikiOptions)) === null || _unref2 === void 0 ? void 0 : _unref2.langAlias) ?? {};
+	});
+	const codeToTokenOptions = computed(() => {
+		var _unref3;
+		return ((_unref3 = unref(options === null || options === void 0 ? void 0 : options.shikiOptions)) === null || _unref3 === void 0 ? void 0 : _unref3.codeToTokenOptions) ?? {};
+	});
+	const isDark = computed(() => unref(options === null || options === void 0 ? void 0 : options.isDark) ?? false);
+	async function getThemes() {
+		const { bundledThemesInfo } = await import("shiki");
+		return [lightTheme.value, darkTheme.value].filter((theme) => bundledThemesInfo.find((t) => t.id === theme));
+	}
+	async function getTheme() {
+		const { bundledThemesInfo } = await import("shiki");
+		const theme = bundledThemesInfo.find((t) => t.id === (isDark.value ? darkTheme.value : lightTheme.value));
+		if (!theme) return isDark.value ? DEFAULT_DARK_THEME : DEFAULT_LIGHT_THEME;
+		return theme.id;
+	}
+	async function getLanguage() {
+		if (LANGUAGE_ALIAS[lang.value]) return LANGUAGE_ALIAS[lang.value];
+		const { bundledLanguagesInfo } = await import("shiki");
+		const language = bundledLanguagesInfo.find((l) => {
+			var _l$aliases;
+			return l.id === lang.value || ((_l$aliases = l.aliases) === null || _l$aliases === void 0 ? void 0 : _l$aliases.includes(lang.value));
+		});
+		if (language) return language.id;
+		return "plaintext";
+	}
+	async function getHighlighter() {
+		if (highlighter) {
+			const loadedLangs = highlighter.getLoadedLanguages();
+			const loadedThemes = highlighter.getLoadedThemes();
+			const language = await getLanguage();
+			const themes = await getThemes();
+			if (!loadedLangs.includes(language)) await highlighter.loadLanguage(language);
+			for (const theme of themes) if (!loadedThemes.includes(theme)) await highlighter.loadTheme(theme);
+			return highlighter;
+		}
+		const { createHighlighter } = await import("shiki");
+		highlighter = await createHighlighter({
+			themes: [await getTheme()],
+			langs: [await getLanguage()],
+			langAlias: {
+				...LANGUAGE_ALIAS,
+				...langAlias.value
+			}
+		});
+		return highlighter;
+	}
+	async function codeToTokens(code) {
+		return (await getHighlighter()).codeToTokens(code, {
+			theme: await getTheme(),
+			lang: await getLanguage(),
+			...codeToTokenOptions.value
+		});
+	}
+	async function preload() {
+		if (highlighter) return;
+		installed.value = await hasShiki();
+		if (installed.value) await getHighlighter();
+	}
+	function dispose() {
+		highlighter === null || highlighter === void 0 || highlighter.dispose();
+		highlighter = null;
+	}
+	(async () => {
+		if (highlighter) {
+			installed.value = true;
+			return;
+		}
+		installed.value = await hasShiki();
+	})();
+	return {
+		installed,
+		getHighlighter,
+		codeToTokens,
+		preload,
+		dispose
+	};
+}
+
+//#endregion
+//#region src/composables/use-tippy.ts
+function useTippy(options) {
+	const isDark = computed(() => unref(options === null || options === void 0 ? void 0 : options.isDark) ?? false);
+	const tippyOptions = computed(() => unref(options === null || options === void 0 ? void 0 : options.options) ?? {});
+	function initTippy() {
+		setDefaultProps({
+			allowHTML: true,
+			delay: [100, 100],
+			theme: isDark.value ? "" : "light",
+			...tippyOptions
+		});
+		watchEffect(() => {
+			setDefaultProps({
+				theme: isDark.value ? "" : "light",
+				...tippyOptions.value
+			});
+		});
+	}
+	return { initTippy };
+}
+
+//#endregion
+//#region src/composables/use-zoom.ts
+function useZoom(options = {}) {
+	const { minZoom = .5, maxZoom = 3, zoomStep = .1, wheelSensitivity = .01, initialZoom = 1, initialTranslateX = 0, initialTranslateY = 0 } = options;
+	const zoom = ref(initialZoom);
+	const translateX = ref(initialTranslateX);
+	const translateY = ref(initialTranslateY);
+	const isDragging = ref(false);
+	const dragStart = ref({
+		x: 0,
+		y: 0
+	});
+	const transformStyle = computed(() => ({ transform: `translate(${translateX.value}px, ${translateY.value}px) scale(${zoom.value})` }));
+	function zoomIn() {
+		if (zoom.value < maxZoom) zoom.value = Math.min(zoom.value + zoomStep, maxZoom);
+	}
+	function zoomOut() {
+		if (zoom.value > minZoom) zoom.value = Math.max(zoom.value - zoomStep, minZoom);
+	}
+	function resetZoom() {
+		zoom.value = initialZoom;
+		translateX.value = initialTranslateX;
+		translateY.value = initialTranslateY;
+	}
+	function setZoom(value) {
+		zoom.value = Math.min(Math.max(value, minZoom), maxZoom);
+	}
+	function startDrag(e) {
+		isDragging.value = true;
+		if (e instanceof MouseEvent) dragStart.value = {
+			x: e.clientX - translateX.value,
+			y: e.clientY - translateY.value
+		};
+		else dragStart.value = {
+			x: e.touches[0].clientX - translateX.value,
+			y: e.touches[0].clientY - translateY.value
+		};
+	}
+	function onDrag(e) {
+		if (!isDragging.value) return;
+		let clientX;
+		let clientY;
+		if (e instanceof MouseEvent) {
+			clientX = e.clientX;
+			clientY = e.clientY;
+		} else {
+			clientX = e.touches[0].clientX;
+			clientY = e.touches[0].clientY;
+		}
+		translateX.value = clientX - dragStart.value.x;
+		translateY.value = clientY - dragStart.value.y;
+	}
+	function stopDrag() {
+		isDragging.value = false;
+	}
+	function handleWheel(event, containerElement) {
+		if (event.ctrlKey || event.metaKey) {
+			event.preventDefault();
+			const rect = containerElement.getBoundingClientRect();
+			const mouseX = event.clientX - rect.left;
+			const mouseY = event.clientY - rect.top;
+			const containerCenterX = rect.width / 2;
+			const containerCenterY = rect.height / 2;
+			const offsetX = mouseX - containerCenterX;
+			const offsetY = mouseY - containerCenterY;
+			const contentMouseX = (offsetX - translateX.value) / zoom.value;
+			const contentMouseY = (offsetY - translateY.value) / zoom.value;
+			const delta = -event.deltaY * wheelSensitivity;
+			const newZoom = Math.min(Math.max(zoom.value + delta, minZoom), maxZoom);
+			if (newZoom !== zoom.value) {
+				translateX.value = offsetX - contentMouseX * newZoom;
+				translateY.value = offsetY - contentMouseY * newZoom;
+				zoom.value = newZoom;
+			}
+		}
+	}
+	function getState() {
+		return {
+			zoom: zoom.value,
+			translateX: translateX.value,
+			translateY: translateY.value
+		};
+	}
+	function setState(state) {
+		if (state.zoom) zoom.value = Math.min(Math.max(state.zoom, minZoom), maxZoom);
+		if (state.translateX) translateX.value = state.translateX;
+		if (state.translateY) translateY.value = state.translateY;
+	}
+	return {
+		zoom,
+		translateX,
+		translateY,
+		isDragging,
+		transformStyle,
+		zoomIn,
+		zoomOut,
+		resetZoom,
+		setZoom,
+		startDrag,
+		onDrag,
+		stopDrag,
+		handleWheel,
+		getState,
+		setState
+	};
+}
+
+//#endregion
+export { transformUrl as A, findNodeParent as C, flow as D, hasShiki as E, LANGUAGE_ALIAS as F, LANGUAGE_EXTENSIONS as I, LANGUAGE_ICONS as L, DEFAULT_HARDEN_OPTIONS as M, DEFAULT_DARK_THEME as N, save as O, DEFAULT_LIGHT_THEME as P, useControls as R, findLastLeafNode as S, hasMermaid as T, escapeMarkdownTableCell as _, useMathRenderer as a, tableDataToMarkdown as b, useKatex as c, currentLocale as d, loadLocaleMessages as f, useHardenSanitizers as g, useHslTheme as h, useMermaid as i, ICONS as j, svgToPngBlob as k, useI18n as l, localesGlob as m, useTippy as n, throttle as o, localeMessages as p, useShiki as r, _defineProperty as s, useZoom as t, SUPPORT_LANGUAGES as u, extractTableDataFromElement as v, hasKatex as w, tableDataToTSV as x, tableDataToCSV as y, useContext as z };