comarkserv 0.1.0

package/dist/dist-BQzCbTko.mjs

@@ -0,0 +1,1693 @@
+import { A as Wr, B as dt$1, D as Ur, E as Un, F as Zr, G as ge$1, I as at$1, K as it$1, L as bn, M as Xr, O as Vn, Q as ot$1, S as Qr, V as ei, W as ft$1, Y as lt$1, _ as Nn, b as Pn, d as Ir, et as qn, g as Mr, h as Lr, it as st$1, k as Vr, l as Hn, lt as vr, m as Kr, mt as g, n as $n, o as Fr, p as Jr, pt as _, q as jn, r as $r, s as Gr, tt as qr, u as Hr, z as ct$1 } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, J as je$1, S as S$1, X as l, ct as s, et as n, g as Ne$1, gt as w$1, j as a, k as _$1, nt as o, o as E$1, ot as r, r as C$1, s as Fe$1, ut as t, vt as y$1 } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+import { n as I$1 } from "./dist-DMftjyxU.mjs";
+//#region node_modules/.pnpm/@twinkleplop+javascript@0.1.4/node_modules/@twinkleplop/javascript/dist/index.js
+var de = /* @__PURE__ */ "if.else.switch.case.default.while.do.for.break.continue.return.var.let.const.function.class.extends.static.async.await.new.typeof.instanceof.in.of.delete.void.try.catch.finally.throw.import.export.from.as.this.super.null.undefined.debugger.with.yield.get.set".split(".");
+var fe = ["true", "false"];
+var pe = [
+	"undefined",
+	"null",
+	"NaN",
+	"Infinity"
+];
+var k = [
+	"return",
+	"throw",
+	"typeof",
+	"new",
+	"void",
+	"delete",
+	"in",
+	"of",
+	"instanceof",
+	"yield",
+	"await",
+	"case",
+	"else"
+];
+var me = de.filter((e) => !k.includes(e));
+var he = [">>>="];
+var ge = [
+	"===",
+	"!==",
+	">>>",
+	"<<=",
+	">>=",
+	"**=",
+	"&&=",
+	"||=",
+	"??="
+];
+var _e = "...";
+var ve = [
+	"++",
+	"--",
+	"<=",
+	">=",
+	"==",
+	"!=",
+	"&&",
+	"||",
+	"<<",
+	">>",
+	"**",
+	"??",
+	"?.",
+	"=>",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&=",
+	"|=",
+	"^="
+];
+var ye = [
+	"-",
+	"+",
+	"<",
+	">",
+	"=",
+	"!",
+	"&",
+	"|",
+	"?",
+	"*",
+	"~",
+	"^",
+	"%"
+];
+var be = [
+	...he,
+	...ge,
+	"...",
+	...ve,
+	...ye
+];
+var A = be.filter((e) => e !== "?.");
+var j = [
+	"===",
+	"!==",
+	"--",
+	"++",
+	"<=",
+	">=",
+	"==",
+	"!=",
+	"&&",
+	"||",
+	"-",
+	"+",
+	"<",
+	">",
+	"=",
+	"!",
+	"&",
+	"|",
+	"?",
+	"*",
+	"/",
+	"~",
+	"^",
+	"%"
+];
+var M = [
+	".",
+	" ",
+	"	",
+	"\n",
+	"\r",
+	")",
+	"[",
+	"]",
+	"{",
+	"}",
+	";",
+	",",
+	":",
+	"`"
+];
+var N = $r("//", "\n", "comment");
+var xe = $r("/*", "*/", "comment");
+var P = Xr("\"", c, Gr("string_double"));
+var Se = Xr("'", c, Gr("string_single"));
+var F = Xr("`", l, Gr("template_literal"));
+var I = [N, xe];
+var L = [
+	P,
+	Se,
+	F
+];
+var R = [Zr([
+	" ",
+	"	",
+	"\n",
+	"\r"
+])];
+var Ce = [
+	Xr(["0x", "0X"], i, Kr("hex_number")),
+	Xr(["0b", "0B"], i, Kr("binary_number")),
+	Xr(["0o", "0O"], i, Kr("octal_number")),
+	Xr(Hr, i, Kr(i))
+];
+var z = [
+	Xr(["0x", "0X"], i, Gr("hex_number_arg")),
+	Xr(["0b", "0B"], i, Gr("binary_number_arg")),
+	Xr(["0o", "0O"], i, Gr("octal_number_arg")),
+	Xr(Hr, i, Gr("number_arg"))
+];
+var B = [
+	...I,
+	...L,
+	...Ce,
+	...R
+];
+var V = [
+	...I,
+	...L,
+	...z
+];
+var H = [
+	...I,
+	...L,
+	...z,
+	...R
+];
+var U = (e, t) => ({ rules: [
+	...I,
+	Zr([
+		" ",
+		"	",
+		"\n",
+		"\r"
+	]),
+	Zr([
+		"_",
+		"$",
+		Vr
+	], Kr(t)),
+	ei(Kr(e))
+] });
+var we = { rules: [
+	...I,
+	Zr([
+		" ",
+		"	",
+		"\n",
+		"\r"
+	]),
+	Xr([
+		"_",
+		"$",
+		Ur
+	], n),
+	ei(Kr("paren_group"))
+] };
+var W = (e) => [Xr("?.", a, Kr(e)), Xr(".", o, Kr(e))];
+var Te = (e) => ({ rules: [
+	...V,
+	...e,
+	Xr(")", o, Kr("division")),
+	Xr("(", o, Gr("paren_group")),
+	Xr(",", o),
+	Xr(["===", "!=="], a),
+	Xr([
+		"--",
+		"++",
+		"<=",
+		">=",
+		"==",
+		"!=",
+		"&&",
+		"||"
+	], a),
+	Xr([
+		"-",
+		"+",
+		"<",
+		">",
+		"=",
+		"!",
+		"&",
+		"|",
+		"?",
+		"*",
+		"~",
+		"^",
+		"%"
+	], a),
+	Xr("/", s, Gr("regex_pattern")),
+	Xr([
+		"[",
+		"]",
+		"{",
+		"}"
+	], o),
+	...W("member_access"),
+	Xr([";", ":"], o),
+	Zr([
+		"_",
+		"$",
+		Vr
+	], Kr("identifier_probe"))
+] });
+var Ee = (t) => ({ rules: [
+	...V,
+	...t,
+	Xr(")", o, qr()),
+	Xr(",", o),
+	...W("member_access_paren"),
+	Xr([
+		"[",
+		"]",
+		"{",
+		"}",
+		";",
+		":"
+	], o),
+	Xr(["===", "!=="], a),
+	Xr([
+		"--",
+		"++",
+		"<=",
+		">=",
+		"==",
+		"!=",
+		"&&",
+		"||"
+	], a),
+	Xr([
+		"-",
+		"+",
+		"<",
+		">",
+		"=",
+		"!",
+		"&",
+		"|",
+		"?",
+		"*",
+		"/",
+		"~",
+		"^",
+		"%"
+	], a),
+	Xr([
+		"_",
+		"$",
+		Ur
+	], n),
+	Xr("(", o, Gr("paren_group"))
+] });
+var De = [
+	Xr(")", o, qr()),
+	Xr(",", o),
+	Xr([
+		"[",
+		"]",
+		"{",
+		"}",
+		";",
+		".",
+		":"
+	], o),
+	Xr(["===", "!=="], a),
+	Xr([
+		"--",
+		"++",
+		"<=",
+		">=",
+		"==",
+		"!=",
+		"&&",
+		"||"
+	], a),
+	Xr([
+		"-",
+		"+",
+		"<",
+		">",
+		"=",
+		"!",
+		"&",
+		"|",
+		"?",
+		"*",
+		"/",
+		"~",
+		"^",
+		"%"
+	], a),
+	Xr([
+		"_",
+		"$",
+		Ur
+	], n)
+];
+var G = (e) => Xr(A, a, Jr(e));
+var K = (e, t) => [
+	Qr(k, Jr(e)),
+	Qr(me, Jr(t)),
+	Qr(pe, Jr(t)),
+	Qr(fe, Jr(t), "boolean")
+];
+var Oe = g({
+	name: "javascript",
+	states: {
+		regex_allow: { rules: [
+			...B,
+			G(null),
+			...K(null, "division"),
+			Xr("/", s, Gr("regex_pattern")),
+			Xr([
+				"(",
+				"{",
+				"["
+			], o),
+			Xr([
+				")",
+				"}",
+				"]"
+			], o, Kr("division")),
+			...W("member_access"),
+			Xr([
+				";",
+				",",
+				":"
+			], o),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("identifier_probe"))
+		] },
+		member_access: U("division", "identifier_probe"),
+		member_access_tmpl: U("tmpl_division", "identifier_probe_tmpl"),
+		identifier_probe: {
+			mode: "probe",
+			fallback: n,
+			rules: [Zr("(", Kr("function_name")), Zr([...M, ...j], Kr(n))]
+		},
+		function_name: { rules: [
+			Xr([
+				"_",
+				"$",
+				Ur
+			], S$1),
+			Xr("(", o, Kr("function_body")),
+			Zr([" ", "	"])
+		] },
+		function_body: Te(K("regex_allow", "division")),
+		paren_group: Ee(K(null, null)),
+		member_access_paren: we,
+		number_arg: { rules: [
+			Xr(["_", Hr], i),
+			Xr(".", i, Kr("decimal_number_arg")),
+			Xr(["e", "E"], i, Kr("exponent_sign_arg")),
+			Xr("n", i, qr()),
+			ei(qr())
+		] },
+		decimal_number_arg: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["e", "E"], i, Kr("exponent_sign_arg")),
+			ei(qr())
+		] },
+		exponent_sign_arg: { rules: [
+			Xr(["+", "-"], i, Kr("exponent_digits_arg")),
+			Xr(Hr, i, Kr("exponent_digits_arg")),
+			ei(qr())
+		] },
+		exponent_digits_arg: { rules: [Xr(["_", Hr], i), ei(qr())] },
+		hex_number_arg: { rules: [
+			Xr(["_", Wr], i),
+			Xr("n", i, qr()),
+			ei(qr())
+		] },
+		binary_number_arg: { rules: [
+			Xr([
+				"_",
+				"0",
+				"1"
+			], i),
+			Xr("n", i, qr()),
+			ei(qr())
+		] },
+		octal_number_arg: { rules: [
+			Xr(["_", Lr([["0", "7"]])], i),
+			Xr("n", i, qr()),
+			ei(qr())
+		] },
+		identifier: { rules: [
+			Xr([
+				"_",
+				"$",
+				Ur
+			], n),
+			F,
+			Xr([
+				"(",
+				"[",
+				"{"
+			], o, Kr("regex_allow")),
+			Xr([
+				")",
+				"]",
+				"}"
+			], o, Kr("division")),
+			Xr([
+				",",
+				";",
+				":"
+			], o, Kr("regex_allow")),
+			...W("member_access"),
+			Xr([...A, "/"], a, Kr("regex_allow")),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("division"))
+		] },
+		division: { rules: [
+			...B,
+			G("regex_allow"),
+			...K("regex_allow", null),
+			Xr([
+				"(",
+				"{",
+				"["
+			], o, Kr("regex_allow")),
+			Xr("/", a, Kr("regex_allow")),
+			Xr([
+				")",
+				"}",
+				"]"
+			], o),
+			Xr([
+				";",
+				",",
+				":"
+			], o, Kr("regex_allow")),
+			...W("member_access"),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("identifier_probe"))
+		] },
+		number: { rules: [
+			Xr(["_", Hr], i),
+			Xr(".", i, Kr("decimal_number")),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			Xr("n", i, Kr("division")),
+			ei(Kr("division"))
+		] },
+		decimal_number: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			ei(Kr("division"))
+		] },
+		exponent_sign: { rules: [
+			Xr(["+", "-"], i, Kr("exponent_digits")),
+			Xr(Hr, i, Kr("exponent_digits")),
+			ei(Kr("division"))
+		] },
+		exponent_digits: { rules: [Xr(["_", Hr], i), ei(Kr("division"))] },
+		hex_number: { rules: [
+			Xr(["_", Wr], i),
+			Xr("n", i, Kr("division")),
+			ei(Kr("division"))
+		] },
+		binary_number: { rules: [
+			Xr([
+				"_",
+				"0",
+				"1"
+			], i),
+			Xr("n", i, Kr("division")),
+			ei(Kr("division"))
+		] },
+		octal_number: { rules: [
+			Xr(["_", Lr([["0", "7"]])], i),
+			Xr("n", i, Kr("division")),
+			ei(Kr("division"))
+		] },
+		string_double: { rules: [
+			Xr("\\u{", Fe$1, Gr("esc_u_braces")),
+			Xr("\\u", Fe$1, Gr("esc_u4_d1")),
+			Xr("\\x", Fe$1, Gr("esc_hex_d1")),
+			Xr("\\", Fe$1, Gr("esc_simple")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		string_single: { rules: [
+			Xr("\\u{", Fe$1, Gr("esc_u_braces")),
+			Xr("\\u", Fe$1, Gr("esc_u4_d1")),
+			Xr("\\x", Fe$1, Gr("esc_hex_d1")),
+			Xr("\\", Fe$1, Gr("esc_simple")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		esc_simple: { rules: [ei({
+			token: Fe$1,
+			exit: !0
+		})] },
+		esc_hex_d1: { rules: [Xr(Wr, Fe$1, Kr("esc_hex_d2")), ei(qr())] },
+		esc_hex_d2: { rules: [Xr(Wr, Fe$1, qr()), ei(qr())] },
+		esc_u4_d1: { rules: [Xr(Wr, Fe$1, Kr("esc_u4_d2")), ei(qr())] },
+		esc_u4_d2: { rules: [Xr(Wr, Fe$1, Kr("esc_u4_d3")), ei(qr())] },
+		esc_u4_d3: { rules: [Xr(Wr, Fe$1, Kr("esc_u4_d4")), ei(qr())] },
+		esc_u4_d4: { rules: [Xr(Wr, Fe$1, qr()), ei(qr())] },
+		esc_u_braces: { rules: [
+			Xr(Wr, Fe$1),
+			Xr("}", Fe$1, qr()),
+			ei(qr())
+		] },
+		template_literal: { rules: [
+			Xr("${", o, Gr("tmpl_regex_allow")),
+			Xr("\\u{", Fe$1, Gr("esc_u_braces")),
+			Xr("\\u", Fe$1, Gr("esc_u4_d1")),
+			Xr("\\x", Fe$1, Gr("esc_hex_d1")),
+			Xr("\\", Fe$1, Gr("esc_simple")),
+			Xr("`", l, qr()),
+			ei({ token: l })
+		] },
+		tmpl_regex_allow: { rules: [
+			...H,
+			G(null),
+			...K(null, "tmpl_division"),
+			Xr("}", o, qr()),
+			Xr("/", s, Gr("regex_pattern")),
+			Xr("{", o, Gr("tmpl_regex_allow")),
+			Xr(["(", "["], o),
+			Xr([")", "]"], o, Kr("tmpl_division")),
+			...W("member_access_tmpl"),
+			Xr([
+				";",
+				",",
+				":"
+			], o),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("identifier_probe_tmpl"))
+		] },
+		tmpl_division: { rules: [
+			...H,
+			G("tmpl_regex_allow"),
+			...K("tmpl_regex_allow", null),
+			Xr("}", o, qr()),
+			Xr("{", o, Gr("tmpl_regex_allow")),
+			Xr(["(", "["], o, Kr("tmpl_regex_allow")),
+			Xr("/", a, Kr("tmpl_regex_allow")),
+			Xr([")", "]"], o),
+			Xr([
+				";",
+				",",
+				":"
+			], o, Kr("tmpl_regex_allow")),
+			...W("member_access_tmpl"),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("identifier_probe_tmpl"))
+		] },
+		identifier_probe_tmpl: {
+			mode: "probe",
+			fallback: "identifier_tmpl",
+			rules: [Zr("(", Kr("function_name_tmpl")), Zr([...M, ...j], Kr("identifier_tmpl"))]
+		},
+		function_name_tmpl: { rules: [
+			Xr([
+				"_",
+				"$",
+				Ur
+			], S$1),
+			Xr("(", o, Kr("function_body_tmpl")),
+			Zr([" ", "	"])
+		] },
+		function_body_tmpl: { rules: [
+			...V,
+			Xr(")", o, Kr("tmpl_division")),
+			Xr("(", o, Gr("paren_group")),
+			Xr(",", o),
+			Xr(["===", "!=="], a),
+			Xr([
+				"--",
+				"++",
+				"<=",
+				">=",
+				"==",
+				"!=",
+				"&&",
+				"||"
+			], a),
+			Xr([
+				"-",
+				"+",
+				"<",
+				">",
+				"=",
+				"!",
+				"&",
+				"|",
+				"?",
+				"*",
+				"~",
+				"^",
+				"%"
+			], a),
+			Xr("/", s, Gr("regex_pattern")),
+			Xr("{", o, Gr("tmpl_regex_allow")),
+			Xr("}", o, qr()),
+			Xr(["[", "]"], o),
+			Xr([
+				";",
+				".",
+				":"
+			], o),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("identifier_probe_tmpl"))
+		] },
+		identifier_tmpl: { rules: [
+			Xr([
+				"_",
+				"$",
+				Ur
+			], n),
+			F,
+			Xr("{", o, Gr("tmpl_regex_allow")),
+			Xr(["(", "["], o, Kr("tmpl_regex_allow")),
+			Xr("}", o, qr()),
+			Xr([")", "]"], o, Kr("tmpl_division")),
+			Xr([
+				",",
+				";",
+				":"
+			], o, Kr("tmpl_regex_allow")),
+			...W("member_access_tmpl"),
+			Xr([...A, "/"], a, Kr("tmpl_regex_allow")),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("tmpl_division"))
+		] },
+		regex_pattern: { rules: [
+			Xr("/", s, Kr("regex_flags")),
+			Xr("\\", s, Gr("regex_escape")),
+			Xr("[", s, Gr("regex_class")),
+			Zr(["\n", ";"], Kr("division")),
+			ei({ token: s })
+		] },
+		regex_escape: { rules: [ei({
+			token: s,
+			exit: !0
+		})] },
+		regex_class: { rules: [
+			Xr("]", s, qr()),
+			Xr("\\", s, Gr("regex_class_escape")),
+			ei({ token: s })
+		] },
+		regex_class_escape: { rules: [ei({
+			token: s,
+			exit: !0
+		})] },
+		regex_flags: { rules: [Xr([
+			"g",
+			"i",
+			"m",
+			"s",
+			"u",
+			"y",
+			"d"
+		], s), ei(qr())] }
+	}
+});
+var ke = [
+	"@param",
+	"@arg",
+	"@argument",
+	"@property",
+	"@prop"
+];
+var Ae = [
+	"@typedef",
+	"@callback",
+	"@template"
+];
+var je = [
+	"<",
+	">",
+	"[",
+	"]",
+	"(",
+	")",
+	",",
+	"|",
+	"&",
+	"=",
+	"?",
+	"!",
+	"*",
+	":",
+	";",
+	"'",
+	"\""
+];
+var Me = Xr([
+	" ",
+	"	",
+	"\r",
+	"\n",
+	"*"
+], t);
+var Ne = g({
+	name: "jsdoc",
+	states: {
+		line_start: { rules: [
+			Me,
+			Qr(ke, Kr("after_name_tag")),
+			Qr(Ae, Kr("after_type_tag")),
+			Xr("@", r, Kr("tag")),
+			ei(Kr("prose"))
+		] },
+		tag: { rules: [Xr([
+			Vr,
+			Hr,
+			"-",
+			"_"
+		], r), ei(Kr("after_tag"))] },
+		after_tag: { rules: [
+			Xr([" ", "	"], t),
+			Xr("{", o, Gr("type_expr")),
+			Xr("\n", t, Kr("line_start")),
+			ei(Kr("prose"))
+		] },
+		after_name_tag: { rules: [
+			Xr([" ", "	"], t),
+			Xr("{", o, Gr("type_expr")),
+			Xr("[", o),
+			Xr("\n", t, Kr("line_start")),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("name")),
+			ei(Kr("prose"))
+		] },
+		after_type_tag: { rules: [
+			Xr([" ", "	"], t),
+			Xr("{", o, Gr("type_expr")),
+			Xr("\n", t, Kr("line_start")),
+			Zr([
+				"_",
+				"$",
+				Vr
+			], Kr("type_name")),
+			ei(Kr("prose"))
+		] },
+		name: { rules: [Xr([
+			"_",
+			"$",
+			".",
+			Ur
+		], _$1), ei(Kr("prose"))] },
+		type_name: { rules: [Xr([
+			"_",
+			"$",
+			".",
+			Ur
+		], y$1), ei(Kr("prose"))] },
+		type_expr: { rules: [
+			Xr("}", o, qr()),
+			Xr("{", o, Gr("type_expr")),
+			Xr("@", r, Kr("inline_tag")),
+			Xr([
+				"_",
+				"$",
+				".",
+				Ur
+			], y$1),
+			Xr(je, o),
+			Me,
+			ei({ token: t })
+		] },
+		inline_tag: { rules: [Xr([
+			Vr,
+			Hr,
+			"-"
+		], r), ei(Kr("type_expr"))] },
+		prose: { rules: [Xr("\n", t, Kr("line_start")), ei({ token: t })] }
+	}
+});
+var Pe;
+var Fe;
+var Ie = (e) => (Pe ??= T())(e);
+var Le = (e) => (Fe ??= I$1())(e);
+var Re = ot$1(it$1("keyword", "function"), at$1(it$1("keyword", "async"), it$1("keyword", "function")));
+var ze = ot$1(at$1(lt$1("(", ")"), it$1("operator", "=>")), at$1(it$1("keyword", "async"), lt$1("(", ")"), it$1("operator", "=>")), at$1(it$1("identifier"), it$1("operator", "=>")), at$1(it$1("keyword", "async"), it$1("identifier"), it$1("operator", "=>")));
+var Be = [{
+	anchor: "identifier",
+	when: at$1(it$1("operator", ["="]), ot$1(Re, ze)),
+	rewrite: "function"
+}];
+var q = ot$1(it$1("punctuation", ":"), it$1("operator", "?:"), at$1(it$1("operator", "?"), it$1("punctuation", ":")));
+var Ve = at$1(st$1(it$1("keyword", "async")), ot$1(it$1("keyword", "function"), at$1(it$1("identifier"), it$1("operator", "=>")), at$1(lt$1("(", ")"), it$1("operator", "=>"))));
+var He = [
+	"object",
+	"interface",
+	"type_literal"
+];
+var Ue = [
+	"class",
+	"interface",
+	"object"
+];
+ot$1(it$1("keyword"), it$1("boolean"));
+var We = [{
+	anchor: {
+		type_name: "identifier",
+		at_start: !0,
+		frame_kinds: ["object"],
+		frame_direct: !0
+	},
+	when: at$1(q, Ve),
+	rewrite: "function"
+}, {
+	anchor: {
+		type_name: "identifier",
+		at_start: !0,
+		frame_kinds: [
+			"object",
+			"interface",
+			"type_literal"
+		],
+		frame_direct: !0
+	},
+	when: at$1(q, dt$1(it$1("keyword", [
+		"for",
+		"while",
+		"do",
+		"if",
+		"switch",
+		"try",
+		"with"
+	]))),
+	rewrite: "property"
+}];
+var Ge = [
+	{
+		anchor: {
+			type_name: "keyword",
+			value: "new",
+			at_start: !0,
+			frame_kinds: ["interface"],
+			frame_direct: !0
+		},
+		when: lt$1("(", ")"),
+		rewrite: "keyword"
+	},
+	{
+		anchor: {
+			type_name: "keyword",
+			at_start: !0,
+			frame_kinds: Ue,
+			frame_direct: !0
+		},
+		when: lt$1("(", ")"),
+		rewrite: "function"
+	},
+	{
+		anchor: {
+			type_name: "keyword",
+			at_start: !0,
+			frame_kinds: He,
+			frame_direct: !0
+		},
+		when: q,
+		rewrite: "identifier"
+	},
+	{
+		anchor: {
+			type_name: "boolean",
+			at_start: !0,
+			frame_kinds: He,
+			frame_direct: !0
+		},
+		when: q,
+		rewrite: "identifier"
+	}
+];
+var Ke = [{
+	anchor: {
+		type_name: "keyword",
+		value: [
+			"function",
+			"yield",
+			"static",
+			"async"
+		]
+	},
+	when: ct$1("star", it$1("operator", "*")),
+	rewrite: { star: "keyword" }
+}, {
+	anchor: {
+		type_name: "operator",
+		value: "*",
+		at_start: !0,
+		frame_kinds: ["class", "object"],
+		frame_direct: !0
+	},
+	rewrite: "keyword"
+}];
+var qe = jn([...Ge, ...Ke], { trivia: ["comment"] });
+var Je = (e, t) => qe(e, t);
+var Ye = jn(We, { trivia: ["comment"] });
+var Xe = [
+	"void",
+	"null",
+	"undefined",
+	"this",
+	"typeof",
+	"keyof",
+	"readonly",
+	"infer",
+	"is",
+	"asserts"
+];
+var Ze = [
+	"void",
+	"null",
+	"undefined",
+	"this"
+];
+var J = {
+	over: [
+		{ type: "identifier" },
+		{ type: "type" },
+		{
+			type: "keyword",
+			texts: Xe
+		},
+		{ type: "string" },
+		{ type: "number" },
+		{ type: "boolean" },
+		{
+			type: "operator",
+			texts: [
+				"|",
+				"&",
+				"<",
+				">",
+				">>",
+				">>>"
+			]
+		},
+		{
+			type: "punctuation",
+			chars: ".[],"
+		}
+	],
+	to: {
+		type: "punctuation",
+		last_char_in: ":",
+		preceded_by_char_in: ")"
+	}
+};
+var Qe = {
+	over: [
+		{ type: "identifier" },
+		{ type: "string" },
+		{ type: "number" },
+		{ type: "boolean" },
+		{
+			type: "keyword",
+			texts: [
+				"this",
+				"null",
+				"undefined"
+			]
+		},
+		{
+			type: "operator",
+			texts: ["-"]
+		},
+		{
+			type: "punctuation",
+			chars: "."
+		}
+	],
+	to: {
+		type: "keyword",
+		texts: ["case", "default"]
+	}
+};
+var Y = [
+	"get",
+	"set",
+	"async",
+	"readonly",
+	"public",
+	"private",
+	"protected",
+	"static",
+	"abstract",
+	"override",
+	"accessor",
+	"declare"
+];
+var $e = {
+	punct_type: "punctuation",
+	brackets: {
+		paren: {
+			open: "(",
+			close: ")"
+		},
+		brace: {
+			open: "{",
+			close: "}"
+		},
+		bracket: {
+			open: "[",
+			close: "]"
+		}
+	},
+	brace_kinds: {
+		body_markers: [{
+			type: "keyword",
+			text: "class",
+			kind: "class"
+		}, {
+			type: "keyword",
+			text: "interface",
+			kind: "interface"
+		}],
+		marker_reset_chars: ";,:",
+		pending_in_angles_kind: "type_literal",
+		angles: {
+			type: "operator",
+			open: "<",
+			closes: [
+				{
+					text: ">",
+					pops: 1
+				},
+				{
+					text: ">>",
+					pops: 2
+				},
+				{
+					text: ">>>",
+					pops: 3
+				}
+			],
+			reset_chars: ";"
+		},
+		prev_rules: [
+			{
+				prev_type: "operator",
+				prev_texts: ["=>"],
+				kind: "block"
+			},
+			{
+				prev_type: "punctuation",
+				prev_last_char_in: "$",
+				kind: "block"
+			},
+			{
+				prev_type: "punctuation",
+				prev_texts: [":"],
+				in_kinds: ["block"],
+				scan_back: Qe,
+				kind: "block"
+			},
+			{
+				prev_type: "punctuation",
+				prev_texts: [":"],
+				kind: "type_literal"
+			},
+			{
+				prev_type: "keyword",
+				prev_texts: [
+					"do",
+					"try",
+					"else",
+					"finally"
+				],
+				kind: "block"
+			},
+			{
+				prev_type: "punctuation",
+				prev_last_char_in: ")",
+				kind: "block"
+			},
+			{
+				prev_type: "identifier",
+				scan_back: J,
+				kind: "block"
+			},
+			{
+				prev_type: "type",
+				scan_back: J,
+				kind: "block"
+			},
+			{
+				prev_type: "keyword",
+				prev_texts: Ze,
+				scan_back: J,
+				kind: "block"
+			},
+			{
+				prev_type: "operator",
+				prev_texts: [
+					">",
+					">>",
+					">>>"
+				],
+				scan_back: J,
+				kind: "block"
+			},
+			{
+				prev_type: "punctuation",
+				prev_last_char_in: "]",
+				scan_back: J,
+				kind: "block"
+			}
+		],
+		default_kind: "object",
+		start_kind: "block"
+	},
+	at_start: {
+		reset_chars: ",;",
+		rearm_after_close_kinds: ["class", "interface"],
+		transparent_texts_for_type: [{
+			type: "keyword",
+			texts: [
+				...Y,
+				"class",
+				"interface"
+			]
+		}, {
+			type: "operator",
+			texts: ["*"]
+		}]
+	}
+};
+var et = vr($e);
+var tt = /* @__PURE__ */ new WeakMap();
+function nt(e) {
+	let t = tt.get(e);
+	return t === void 0 && (t = {
+		identifier_id: e.indexOf("identifier"),
+		template_id: e.indexOf("template"),
+		punctuation_id: e.indexOf("punctuation")
+	}, tt.set(e, t)), t;
+}
+function rt(e, t, n, r) {
+	let { identifier_id: i, template_id: a, punctuation_id: o } = nt(r);
+	if (i < 0 || a < 0 || o < 0) return null;
+	let s = e.length / 3;
+	if (n >= s || e[n * 3] !== i) return null;
+	let c = e[n * 3 + 1], l = e[n * 3 + 2], u = t.slice(c, l), d;
+	if (u === "html") d = Ie;
+	else if (u === "css") d = Le;
+	else return null;
+	let f = n + 1;
+	if (f >= s || e[f * 3] !== a) return null;
+	let p = e[f * 3 + 1];
+	if (t[p] !== "`") return null;
+	let m = [];
+	m.push({
+		kind: "synthetic",
+		source_start: p,
+		source_end: p + 1,
+		type_name: "template"
+	});
+	let h = f, g = !1, _ = 0, v = 0, y = 0;
+	for (; h < s;) {
+		let n = e[h * 3], r = e[h * 3 + 1], i = e[h * 3 + 2];
+		if (g) {
+			if (n === o) {
+				let e = t.slice(r, i);
+				for (let t = 0; t < e.length; t++) {
+					let n = e.charCodeAt(t);
+					n === 123 ? _++ : n === 125 && _--;
+				}
+				_ === 0 && (m.push({
+					kind: "hole",
+					source_start: y,
+					source_end: i,
+					token_start: v,
+					token_end: h + 1
+				}), g = !1);
+			}
+			h++;
+		} else if (n === a) {
+			let e = +(h === f), n = i - r > e && t[i - 1] === "`", a = r + e, o = n ? i - 1 : i;
+			if (o > a && m.push({
+				kind: "content",
+				source_start: a,
+				source_end: o
+			}), h++, n) return m.push({
+				kind: "synthetic",
+				source_start: i - 1,
+				source_end: i,
+				type_name: "template"
+			}), {
+				token_start: f,
+				token_end: h,
+				regions: m,
+				language: d
+			};
+		} else if (n === o && t.slice(r, i) === "${") g = !0, v = h, y = r, _ = 1, h++;
+		else return null;
+	}
+	return null;
+}
+var it = /* @__PURE__ */ new WeakMap();
+function at(e) {
+	let t = it.get(e);
+	return t === void 0 && (t = e.indexOf("comment"), it.set(e, t)), t;
+}
+var ot;
+var st = (e) => (ot ??= qn(_(Ne))())(e);
+function ct(e, t, n, r) {
+	let i = at(r);
+	if (i < 0 || n >= e.length / 3 || e[n * 3] !== i) return null;
+	let a = e[n * 3 + 1], o = e[n * 3 + 2];
+	return o - a <= 3 || t.charCodeAt(a) !== 47 || t.charCodeAt(a + 1) !== 42 || t.charCodeAt(a + 2) !== 42 ? null : {
+		token_start: n,
+		token_end: n + 1,
+		regions: [{
+			kind: "synthetic",
+			source_start: a,
+			source_end: a + 3,
+			type_name: "comment"
+		}, {
+			kind: "content",
+			source_start: a + 3,
+			source_end: o
+		}],
+		language: st
+	};
+}
+var lt = Un((e, t, n, r) => {
+	let i = $n(e, t, n), a = i.count;
+	if (a === 0) return;
+	let o = n.indexOf("identifier"), s = n.indexOf("keyword"), c = n.indexOf("punctuation"), l = n.indexOf("operator"), u = n.indexOf("type"), d = n.indexOf("function");
+	if (o < 0 || s < 0) return;
+	let f = n.indexOf("class_name");
+	f < 0 && (f = n.length, n.push("class_name"));
+	let p = bn("class_name"), m = (e) => i.next_non_trivia(e), h = (e) => {
+		if (e < 0 || e >= a) return !1;
+		let t = i.kind_of(e);
+		return t === o || t === u || t === d;
+	}, g = (e) => {
+		if (e < 0 || e >= a || i.kind_of(e) !== l || i.text_of(e) !== "<") return e;
+		let t = 1, n = e + 1;
+		for (; n < a && t > 0;) {
+			if (!i.is_trivia(n) && i.kind_of(n) === l) {
+				let e = i.text_of(n);
+				e === "<" ? t++ : e === ">" && t--;
+			}
+			n++;
+		}
+		return n;
+	}, v = (e) => {
+		let t = m(e), n = -1;
+		for (; t >= 0 && t < a && h(t);) {
+			if (n = t, t = m(t + 1), t >= 0 && i.kind_of(t) === c && i.text_of(t) === ".") {
+				t = m(t + 1);
+				continue;
+			}
+			break;
+		}
+		return n >= 0 && r.emit(n, f, p), t < 0 ? a : t;
+	}, y = (e) => {
+		let t = m(e);
+		for (; t >= 0 && t < a && h(t);) {
+			if (t = v(t), t = m(t), t >= 0 && i.kind_of(t) === l && i.text_of(t) === "<" && (t = g(t), t = m(t)), t >= 0 && i.kind_of(t) === c && i.text_of(t) === ",") {
+				t = m(t + 1);
+				continue;
+			}
+			break;
+		}
+		return t < 0 ? a : t;
+	};
+	for (let e = 0; e < a; e++) {
+		if (i.is_trivia(e) || i.kind_of(e) !== s) continue;
+		let t = i.text_of(e);
+		if (t === "class" || t === "interface") {
+			let t = m(e + 1);
+			h(t) && (r.emit(t, f, p), t = m(t + 1)), t >= 0 && i.kind_of(t) === l && i.text_of(t) === "<" && (t = g(t), t = m(t));
+			for (let e = 0; e < 2; e++) {
+				if (t = m(t), t >= 0 && i.kind_of(t) === s && (i.text_of(t) === "extends" || i.text_of(t) === "implements")) {
+					t = y(t + 1);
+					continue;
+				}
+				break;
+			}
+			continue;
+		}
+		if (t === "new" || t === "instanceof") {
+			v(e + 1);
+			continue;
+		}
+	}
+});
+var ut = Mr("identifier", "boolean", ["true", "false"]);
+var dt = Ir("identifier", "function", { plain: !0 }, { trivia: ["comment"] });
+var ft = Fr("identifier", "constant");
+var pt = 25;
+function mt(e, t, n, r) {
+	let i = e.next_non_trivia(t + 1);
+	if (i < 0) return -1;
+	let a = e.next_non_trivia(i + 1);
+	return a >= 0 && e.kind_of(a) === r && e.text_of(a) === "," ? i = e.next_non_trivia(a + 1) : e.text_of(i) === "type" && (i = a), i < 0 || e.kind_of(i) !== n || e.text_of(i) !== "*" ? -1 : i;
+}
+var ht = bn("constant");
+var X = Un((e, t, n, r) => {
+	let i = n.indexOf("identifier"), a = n.indexOf("keyword"), o = n.indexOf("operator"), s = n.indexOf("punctuation");
+	if (i < 0 || a < 0 || o < 0 || s < 0) return;
+	let c = n.indexOf("constant");
+	c < 0 && (c = n.length, n.push("constant"));
+	let l = $n(e, t, n), u = l.count;
+	for (let e = 0; e < u; e++) {
+		if (l.is_trivia(e) || l.kind_of(e) !== a) continue;
+		let t = l.text_of(e);
+		if (t === "import" || t === "export") {
+			let t = mt(l, e, o, s);
+			t >= 0 && r.emit(t, c, ht);
+			continue;
+		}
+		if (t !== "const") continue;
+		let n = 0, d = [], f = 0, p = !0, m = !1, h = 0, g = l.next_non_trivia(e + 1);
+		if (!(g < 0)) for (; g < u; g++) {
+			if (l.is_trivia(g)) continue;
+			let e = l.kind_of(g), t = l.text_of(g);
+			if (e === s) {
+				for (let e = 0; e < t.length; e++) {
+					let r = t[e];
+					if (r === "{") n++, d.push(!0), p = !0;
+					else if (r === "[") n++, d.push(!1), p = !0;
+					else if (r === "(") n++, d.push(!1), p = !1;
+					else if (r === "}" || r === "]" || r === ")") {
+						if (n === 0) {
+							g = u;
+							break;
+						}
+						n--, d.pop(), m && n < h && (m = !1), p = !1;
+					} else if (r === ",") m && n === h && f === 0 && (m = !1), m || (p = !0);
+					else if (r === ";") {
+						if (n === 0) {
+							g = u;
+							break;
+						}
+					} else r === ":" ? n > 0 && d[d.length - 1] ? p = !0 : m || (m = !0, h = n) : p = !1;
+				}
+				continue;
+			}
+			if (e === o) {
+				if (t === "<") {
+					f++, p = !1;
+					continue;
+				}
+				if (t === ">") {
+					f > 0 && f--, p = !1;
+					continue;
+				}
+				if (t === ">>") {
+					f >= 2 ? f -= 2 : f = 0, p = !1;
+					continue;
+				}
+				if (t === ">>>") {
+					f >= 3 ? f -= 3 : f = 0, p = !1;
+					continue;
+				}
+				if (t === "=" && !m) {
+					m = !0, h = n, p = !1;
+					continue;
+				}
+				if (t === "..." && !m) {
+					p = !0;
+					continue;
+				}
+				p = !1;
+				continue;
+			}
+			if (e === a) {
+				if ((t === "of" || t === "in") && n === 0) {
+					g = u;
+					break;
+				}
+				p = !1;
+				continue;
+			}
+			if (e === i && !m && p) {
+				let e = n > 0 && d[d.length - 1], t = !1;
+				if (e) {
+					let e = l.next_non_trivia(g + 1);
+					e >= 0 && l.kind_of(e) === s && l.text_of(e) === ":" && (t = !0);
+				}
+				t || r.emit(g, c, pt);
+			}
+			p = !1;
+		}
+	}
+});
+var Z = {
+	into: "p",
+	default_introducer: "=",
+	transparent_texts_for_type: [{
+		type: "operator",
+		texts: ["..."]
+	}, {
+		type: "keyword",
+		texts: Y
+	}]
+};
+var gt = [
+	"class",
+	"object",
+	"interface"
+];
+var Q = (e, t) => ({
+	anchor: {
+		type_name: e,
+		value: t,
+		at_start: !0,
+		frame_kinds: gt,
+		frame_direct: !0
+	},
+	when: ft$1({
+		...Z,
+		skip_generics: !0
+	}),
+	rewrite: { p: "parameter" }
+});
+var _t = jn([
+	{
+		anchor: it$1("keyword", "function"),
+		when: at$1(st$1(it$1("operator", "*")), st$1(ot$1(it$1("identifier"), it$1("function"))), ft$1({
+			...Z,
+			skip_generics: !0
+		})),
+		rewrite: { p: "parameter" }
+	},
+	Q("identifier"),
+	Q("function"),
+	Q("keyword", Y),
+	{
+		anchor: "punctuation",
+		when: ft$1({
+			...Z,
+			find_open: "arrow",
+			skip_ts_return_type: !0,
+			skip_in_type_position: !0
+		}),
+		rewrite: { p: "parameter" }
+	},
+	{
+		anchor: "identifier",
+		when: it$1("operator", "=>"),
+		rewrite: "parameter"
+	},
+	{
+		anchor: "function",
+		when: it$1("operator", "=>"),
+		rewrite: "parameter"
+	}
+], { trivia: ["comment"] });
+var vt = 46;
+var yt = Un((e, t, n, r) => {
+	let i = n.indexOf("identifier"), a = n.indexOf("keyword"), o = n.indexOf("operator"), s = n.indexOf("punctuation");
+	if (i < 0 || a < 0) return;
+	let c = n.indexOf("namespace");
+	c < 0 && (c = n.length, n.push("namespace"));
+	let l = vt, u = $n(e, t, n), d = u.count;
+	for (let e = 0; e < d; e++) {
+		if (u.is_trivia(e) || u.kind_of(e) !== a) continue;
+		let t = u.text_of(e);
+		if (t === "import" || t === "export") {
+			let t = mt(u, e, o, s);
+			if (t < 0) continue;
+			let n = u.next_non_trivia(t + 1);
+			if (n < 0 || u.kind_of(n) !== a || u.text_of(n) !== "as") continue;
+			let d = u.next_non_trivia(n + 1);
+			d >= 0 && u.kind_of(d) === i && r.emit(d, c, l);
+			continue;
+		}
+		if (t === "namespace" || t === "module") {
+			let t = u.next_non_trivia(e + 1);
+			t >= 0 && u.kind_of(t) === i && r.emit(t, c, l);
+			continue;
+		}
+	}
+});
+function bt(e, t, n, r) {
+	return rt(e, t, n, r) ?? ct(e, t, n, r);
+}
+var xt = [
+	Hn(et, "type_claim"),
+	Hn(Je, "shape"),
+	Vn(ft, ["constant"]),
+	Vn(jn(Be, { trivia: ["comment"] }), ["function"]),
+	Vn(X, ["constant"]),
+	Vn(Ye, ["property"]),
+	Vn(lt, ["class_name"]),
+	Vn(_t, ["parameter"]),
+	Vn(yt, ["namespace"]),
+	Hn(Pn({ scan: bt }), "embed")
+];
+var St = _(Oe);
+var $ = qn(St, xt);
+function Ct(e) {
+	let t = $(e);
+	return (e, n) => ge$1(e, t(e), n);
+}
+//#endregion
+//#region node_modules/.pnpm/@twinkleplop+html@0.1.4/node_modules/@twinkleplop/html/dist/index.js
+var v = Lr([
+	["a", "z"],
+	["A", "Z"],
+	["0", "9"],
+	["-", "-"],
+	["_", "_"],
+	[":", ":"]
+]);
+var y = [
+	Zr([
+		" ",
+		"	",
+		"\n",
+		"\r"
+	]),
+	Xr("=", a),
+	$r("\"", "\"", c),
+	$r("'", "'", c),
+	Xr(v, C$1)
+];
+var b = g({
+	name: "html",
+	states: {
+		content: { rules: [
+			$r("<!--", "-->", t),
+			Xr(["<!DOCTYPE", "<!doctype"], w$1, Gr("doctype")),
+			Xr("</", o, Gr("close_tag")),
+			Xr("<", o, Gr("tag_start")),
+			ei({})
+		] },
+		tag_start: { rules: [
+			Qr(["script"], Kr("script_attrs"), E$1),
+			Qr(["style"], Kr("style_attrs"), E$1),
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("tag_attrs")),
+			Xr(v, E$1, Kr("tag_open"))
+		] },
+		tag_open: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("tag_attrs")),
+			Xr(v, E$1)
+		] },
+		tag_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			...y
+		] },
+		close_tag: { rules: [
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr(v, E$1)
+		] },
+		doctype: { rules: [Xr(">", o, qr()), ei({ token: w$1 })] },
+		script_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, Kr("script_content")),
+			...y
+		] },
+		script_content: { rules: [Zr("</", Gr("script_close_probe")), ei({ token: je$1 })] },
+		script_close_probe: {
+			mode: "probe",
+			fallback: "script_close_fail",
+			rules: [Zr("script>", Kr("script_close_emit"))]
+		},
+		script_close_fail: { rules: [Xr("<", je$1, qr())] },
+		script_close_emit: { rules: [Xr("</", o, Kr("script_close_name"))] },
+		script_close_name: { rules: [Xr("script", E$1, Kr("script_close_gt"))] },
+		script_close_gt: { rules: [Xr(">", o, qr())] },
+		style_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, Kr("style_content")),
+			...y
+		] },
+		style_content: { rules: [Zr("</", Gr("style_close_probe")), ei({ token: Ne$1 })] },
+		style_close_probe: {
+			mode: "probe",
+			fallback: "style_close_fail",
+			rules: [Zr("style>", Kr("style_close_emit"))]
+		},
+		style_close_fail: { rules: [Xr("<", Ne$1, qr())] },
+		style_close_emit: { rules: [Xr("</", o, Kr("style_close_name"))] },
+		style_close_name: { rules: [Xr("style", E$1, Kr("style_close_gt"))] },
+		style_close_gt: { rules: [Xr(">", o, qr())] }
+	}
+});
+var x;
+var S;
+var C = [Hn(Nn({
+	raw_script: (e) => (x ??= $())(e),
+	raw_style: (e) => (S ??= I$1())(e)
+}), "embed")];
+var w = _(b);
+var T = qn(w, C);
+function E(e) {
+	let t = T(e);
+	return (e, n) => ge$1(e, t(e), n);
+}
+//#endregion
+export { ut as $, U as A, de as B, N as C, Se as D, R as E, _e as F, ge as G, et as H, _t as I, k as J, he as K, be as L, W as M, X as N, St as O, Ye as P, rt as Q, bt as R, M as S, P as T, fe as U, dt as V, ft as W, me as X, lt as Y, pe as Z, H as _, w as a, yt as at, K as b, A as c, Ce as d, ve as et, Ct as f, G as g, F as h, b as i, ye as it, V as j, Te as k, B as l, Ee as m, E as n, xe as nt, $ as o, z as ot, De as p, j as q, T as r, xt as rt, $e as s, C as t, we as tt, Be as u, I as v, Oe as w, L as x, Je as y, ct as z };