comarkserv 0.1.0

package/dist/dist-DMftjyxU.mjs

@@ -0,0 +1,370 @@
+import { A as Wr, D as Ur, F as Zr, G as ge, I as at, K as it, M as Xr, O as Vn, V as ei, et as qn, h as Lr, k as Vr, m as Kr, mt as g, pt as _, q as jn, r as $r, s as Gr, tt as qr, u as Hr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, Y as k$1, _ as O$1, et as n, ft as u, h as M$1, i as D$1, j as a, mt as v, n as A$1, nt as o, ot as r, q as j$1, s as Fe, ut as t } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+css@0.1.4/node_modules/@twinkleplop/css/dist/index.js
+var x = $r("/*", "*/", t);
+var S = Xr("\"", c, Gr("string_double"));
+var C = Xr("'", c, Gr("string_single"));
+var w = Xr("#", A$1, Gr("id_selector"));
+var T = Xr(".", k$1, Gr("class_selector"));
+var E = Xr("::", j$1, Gr("pseudo_class"));
+var D = Xr(":", j$1, Gr("pseudo"));
+var O = Xr("&", O$1, Gr("nested_selector"));
+var k = Xr("#", i, Gr("hex_color"));
+var A = Xr("--", D$1, Gr("css_custom_property"));
+var j = Xr([
+	"~=",
+	"|=",
+	"^=",
+	"$=",
+	"*=",
+	"="
+], a);
+var M = Xr([
+	">",
+	"+",
+	"~"
+], a);
+var N = g({
+	name: "css",
+	states: {
+		main: { rules: [
+			x,
+			S,
+			C,
+			Xr("@", r, Gr("at_rule")),
+			Xr("{", o, Gr("declaration")),
+			Xr("}", o),
+			Xr([
+				";",
+				")",
+				"]",
+				","
+			], o),
+			Xr("(", o, Gr("parentheses")),
+			Xr("[", o, Gr("brackets")),
+			w,
+			T,
+			E,
+			D,
+			j,
+			M,
+			Xr("*", O$1),
+			Zr("-", Gr("negative_number_or_identifier")),
+			Xr(Hr, i, Gr("number")),
+			Xr(Vr, O$1, Gr("identifier"))
+		] },
+		declaration: { rules: [
+			x,
+			Xr("}", o, qr()),
+			Xr("{", o, Gr("declaration")),
+			Xr(";", o),
+			Xr("@", r, Gr("at_rule")),
+			O,
+			T,
+			w,
+			E,
+			Xr("--", D$1, Gr("css_custom_property_declaration")),
+			Xr(":", o, Gr("value")),
+			Zr("-", Gr("probe_identifier")),
+			Zr(Vr, Gr("probe_identifier"))
+		] },
+		value: { rules: [
+			x,
+			S,
+			C,
+			Xr(";", o, qr()),
+			Xr("}", o, qr()),
+			Xr("!", r, Gr("important")),
+			k,
+			Xr("(", o, Gr("function_args")),
+			A,
+			Xr("-", a, Gr("after_minus")),
+			Xr(Hr, i, Gr("number")),
+			Xr(".", i, Gr("decimal")),
+			Xr(Vr, n, Gr("value_identifier")),
+			Xr([
+				",",
+				"/",
+				"+",
+				"*"
+			], a)
+		] },
+		probe_identifier: {
+			mode: "probe",
+			fallback: "property",
+			rules: [Zr("{", Gr("selector")), Zr([";", "}"], Gr("property"))]
+		},
+		nested_selector: { rules: [
+			D,
+			E,
+			T,
+			w,
+			Xr("[", o, Gr("brackets")),
+			Xr("{", o, Gr("declaration")),
+			M,
+			ei(qr())
+		] },
+		at_rule: { rules: [
+			S,
+			C,
+			Xr(Vr, r),
+			Xr("-", r),
+			Xr("(", o, Gr("media_params")),
+			Xr("{", o, qr()),
+			Xr(";", o, qr())
+		] },
+		media_params: { rules: [
+			x,
+			S,
+			C,
+			Xr(")", o, qr()),
+			Xr("(", o, Gr("media_params")),
+			Xr(":", o),
+			Xr(",", o),
+			Xr(";", o),
+			Xr("=", a),
+			Xr([">", "<"], a),
+			Xr(Hr, i, Gr("number")),
+			Xr(".", i, Gr("decimal")),
+			Xr(Vr, r, Gr("media_keyword")),
+			Xr("-", r, Gr("media_keyword"))
+		] },
+		media_keyword: { rules: [
+			Zr([
+				":",
+				",",
+				";",
+				")",
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], qr()),
+			Xr(Ur, r),
+			Xr(["-", "_"], r),
+			ei(qr())
+		] },
+		property: { rules: [
+			Xr(Ur, v),
+			Xr(["-", "_"], v),
+			Xr(":", o, Gr("value")),
+			ei(qr())
+		] },
+		selector: { rules: [
+			Xr(Ur, O$1),
+			Xr(["-", "_"], O$1),
+			Xr(":", j$1, Gr("pseudo")),
+			Xr("{", o, Gr("declaration")),
+			ei(qr())
+		] },
+		id_selector: { rules: [
+			Xr(Ur, A$1),
+			Xr(["-", "_"], A$1),
+			ei(qr())
+		] },
+		class_selector: { rules: [
+			Xr(Ur, k$1),
+			Xr(["-", "_"], k$1),
+			ei(qr())
+		] },
+		pseudo: { rules: [
+			Xr(Vr, j$1),
+			Xr("-", j$1),
+			Xr("(", o, Gr("parentheses")),
+			ei(qr())
+		] },
+		pseudo_class: { rules: [
+			Xr(Vr, j$1),
+			Xr("-", j$1),
+			ei(qr())
+		] },
+		parentheses: { rules: [
+			Xr(")", o, qr()),
+			Xr("(", o, Gr("parentheses")),
+			Xr(Lr([[0, 127]]), n)
+		] },
+		brackets: { rules: [
+			Xr("]", o, qr()),
+			S,
+			C,
+			j,
+			Xr(Ur, u),
+			Xr(["-", "_"], u)
+		] },
+		number: { rules: [
+			Xr(Hr, i),
+			Xr(".", i, Gr("decimal")),
+			Xr(Vr, M$1, Gr("unit")),
+			Xr("%", M$1, qr()),
+			ei(qr())
+		] },
+		decimal: { rules: [
+			Xr(Hr, i),
+			Xr(Vr, M$1, Gr("unit")),
+			Xr("%", M$1, qr()),
+			ei(qr())
+		] },
+		after_minus: { rules: [
+			Xr(Hr, i, Gr("number")),
+			Xr(".", i, Gr("decimal")),
+			Xr("-", D$1, Gr("css_custom_property")),
+			Xr(Vr, n, Gr("value_identifier")),
+			ei(qr())
+		] },
+		unit: { rules: [Xr(Vr, M$1), ei(qr())] },
+		hex_color: { rules: [Xr(Wr, i), ei(qr())] },
+		css_custom_property: { rules: [
+			Xr(Ur, D$1),
+			Xr(["-", "_"], D$1),
+			ei(qr())
+		] },
+		css_custom_property_declaration: { rules: [
+			Xr(Ur, D$1),
+			Xr(["-", "_"], D$1),
+			Xr(":", o, Gr("value")),
+			ei(qr())
+		] },
+		value_identifier: { rules: [
+			Xr(Ur, n),
+			Xr(["-", "_"], n),
+			Xr("(", o, Gr("function_args")),
+			ei(qr())
+		] },
+		function_args: { rules: [
+			x,
+			S,
+			C,
+			Xr(")", o, qr()),
+			Xr("(", o, Gr("function_args")),
+			Xr("#", i, Gr("hex_color")),
+			Xr("--", D$1, Gr("css_custom_property")),
+			Xr(Hr, i, Gr("number")),
+			Xr(".", n, Gr("url_filename")),
+			Xr(Vr, n, Gr("identifier_in_function")),
+			Xr([
+				",",
+				"/",
+				"+",
+				"*",
+				"-"
+			], a)
+		] },
+		url_filename: { rules: [
+			Xr(Ur, n),
+			Xr([
+				".",
+				"-",
+				"_",
+				"/",
+				":"
+			], n),
+			ei(qr())
+		] },
+		identifier_in_function: { rules: [
+			Xr(Ur, n),
+			Xr(["-", "_"], n),
+			ei(qr())
+		] },
+		important: { rules: [Xr("important", r, qr())] },
+		identifier: { rules: [
+			Xr(Ur, O$1),
+			Xr(["-", "_"], O$1),
+			ei(qr())
+		] },
+		negative_number_or_identifier: { rules: [
+			Xr(Hr, i, Gr("number")),
+			Xr(Vr, O$1, Gr("identifier")),
+			Xr("-", O$1),
+			ei(qr())
+		] },
+		string_double: { rules: [
+			Xr("\\", Fe, Gr("esc_start")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		string_single: { rules: [
+			Xr("\\", Fe, Gr("esc_start")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		esc_start: { rules: [Xr(Wr, Fe, Kr("esc_hex_d2")), ei({
+			token: Fe,
+			exit: !0
+		})] },
+		esc_hex_d2: { rules: [
+			Xr(Wr, Fe, Kr("esc_hex_d3")),
+			Xr([
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"\f"
+			], Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex_d3: { rules: [
+			Xr(Wr, Fe, Kr("esc_hex_d4")),
+			Xr([
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"\f"
+			], Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex_d4: { rules: [
+			Xr(Wr, Fe, Kr("esc_hex_d5")),
+			Xr([
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"\f"
+			], Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex_d5: { rules: [
+			Xr(Wr, Fe, Kr("esc_hex_d6")),
+			Xr([
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"\f"
+			], Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex_d6: { rules: [
+			Xr(Wr, Fe, Kr("esc_hex_done")),
+			Xr([
+				" ",
+				"	",
+				"\n",
+				"\r",
+				"\f"
+			], Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex_done: { rules: [Xr([
+			" ",
+			"	",
+			"\n",
+			"\r",
+			"\f"
+		], Fe, qr()), ei(qr())] }
+	}
+});
+var P = [Vn(jn([{
+	anchor: "identifier",
+	when: at(it("punctuation", "(")),
+	rewrite: "function"
+}], { trivia: ["comment"] }), ["function"])];
+var F = _(N);
+var I = qn(F, P);
+function L(e) {
+	let t = I(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { P as a, N as i, I as n, L as r, F as t };

package/dist/dist-Dr9uTCX7.mjs

@@ -0,0 +1,2 @@
+import { a as P, i as N, n as I, r as L, t as F } from "./dist-DMftjyxU.mjs";
+export { F as grammar, L as language, N as raw_grammar, P as reclassifiers, I as tokenize };

package/dist/dist-Dxvc11TH.mjs

@@ -0,0 +1,339 @@
+import { A as Wr, D as Ur, E as Un, F as Zr, G as ge, I as at, K as it, M as Xr, O as Vn, Q as ot, S as Qr, V as ei, W as ft, et as qn, h as Lr, it as st, k as Vr, m as Kr, mt as g, n as $n, o as Fr, pt as _, q as jn, s as Gr, tt as qr, u as Hr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, S, et as n, j as a, nt as o, s as Fe, ut as t, z as e } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+go@0.1.4/node_modules/@twinkleplop/go/dist/index.js
+var D = [
+	"break",
+	"case",
+	"chan",
+	"const",
+	"continue",
+	"default",
+	"defer",
+	"else",
+	"fallthrough",
+	"for",
+	"func",
+	"go",
+	"goto",
+	"if",
+	"import",
+	"interface",
+	"map",
+	"package",
+	"range",
+	"return",
+	"select",
+	"struct",
+	"switch",
+	"type",
+	"var"
+];
+var O = ["nil", "iota"];
+var k = [
+	"any",
+	"bool",
+	"byte",
+	"comparable",
+	"complex64",
+	"complex128",
+	"error",
+	"float32",
+	"float64",
+	"int",
+	"int8",
+	"int16",
+	"int32",
+	"int64",
+	"rune",
+	"string",
+	"uint",
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64",
+	"uintptr"
+];
+var A = [
+	"append",
+	"cap",
+	"clear",
+	"close",
+	"complex",
+	"copy",
+	"delete",
+	"imag",
+	"len",
+	"make",
+	"max",
+	"min",
+	"new",
+	"panic",
+	"print",
+	"println",
+	"real",
+	"recover"
+];
+var j = ["true", "false"];
+var M = /* @__PURE__ */ "<<=,>>=,&^=,...,&^,+=,-=,*=,/=,%=,&=,|=,^=,<<,>>,&&,||,==,!=,<=,>=,<-,++,--,:=,+,-,*,/,%,&,|,^,<,>,=,!,~".split(",");
+var N = g({
+	name: "go",
+	states: {
+		main: { rules: [
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr("//", t, Gr("line_comment")),
+			Xr("/*", t, Gr("block_comment")),
+			Xr("\"", c, Gr("string_body")),
+			Xr("`", c, Gr("raw_string_body")),
+			Xr("'", c, Gr("rune_body")),
+			Xr([
+				".0",
+				".1",
+				".2",
+				".3",
+				".4",
+				".5",
+				".6",
+				".7",
+				".8",
+				".9"
+			], i, Gr("decimal_fraction")),
+			Xr(M, a),
+			Xr([
+				"(",
+				")",
+				"[",
+				"]",
+				"{",
+				"}",
+				",",
+				";",
+				":",
+				"."
+			], o),
+			Qr(D),
+			Qr(j, {}, e),
+			Qr(O),
+			Qr(k),
+			Qr(A, {}, S),
+			Xr(["0x", "0X"], i, Gr("hex_number")),
+			Xr(["0b", "0B"], i, Gr("binary_number")),
+			Xr(["0o", "0O"], i, Gr("octal_number")),
+			Xr(Hr, i, Gr("decimal_number")),
+			Xr(["_", Vr], n, Gr("identifier"))
+		] },
+		identifier: { rules: [Xr(["_", Ur], n), ei(qr())] },
+		line_comment: { rules: [Xr("\n", t, qr()), ei({ token: t })] },
+		block_comment: { rules: [Xr("*/", t, qr()), ei({ token: t })] },
+		string_body: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		raw_string_body: { rules: [Xr("`", c, qr()), ei({ token: c })] },
+		rune_body: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		string_escape_start: { rules: [
+			Xr("x", Fe, Kr("esc_hex_d1")),
+			Xr("u", Fe, Kr("esc_u4_d1")),
+			Xr("U", Fe, Kr("esc_u8_d1")),
+			Xr(Lr([["0", "7"]]), Fe, Kr("esc_oct_d2")),
+			ei({
+				token: Fe,
+				exit: !0
+			})
+		] },
+		esc_hex_d1: { rules: [Xr(Wr, Fe, Kr("esc_hex_d2")), ei(qr())] },
+		esc_hex_d2: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_u4_d1: { rules: [Xr(Wr, Fe, Kr("esc_u4_d2")), ei(qr())] },
+		esc_u4_d2: { rules: [Xr(Wr, Fe, Kr("esc_u4_d3")), ei(qr())] },
+		esc_u4_d3: { rules: [Xr(Wr, Fe, Kr("esc_u4_d4")), ei(qr())] },
+		esc_u4_d4: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_u8_d1: { rules: [Xr(Wr, Fe, Kr("esc_u8_d2")), ei(qr())] },
+		esc_u8_d2: { rules: [Xr(Wr, Fe, Kr("esc_u8_d3")), ei(qr())] },
+		esc_u8_d3: { rules: [Xr(Wr, Fe, Kr("esc_u8_d4")), ei(qr())] },
+		esc_u8_d4: { rules: [Xr(Wr, Fe, Kr("esc_u8_d5")), ei(qr())] },
+		esc_u8_d5: { rules: [Xr(Wr, Fe, Kr("esc_u8_d6")), ei(qr())] },
+		esc_u8_d6: { rules: [Xr(Wr, Fe, Kr("esc_u8_d7")), ei(qr())] },
+		esc_u8_d7: { rules: [Xr(Wr, Fe, Kr("esc_u8_d8")), ei(qr())] },
+		esc_u8_d8: { rules: [Xr(Wr, Fe, qr()), ei(qr())] },
+		esc_oct_d2: { rules: [Xr(Lr([["0", "7"]]), Fe, Kr("esc_oct_d3")), ei(qr())] },
+		esc_oct_d3: { rules: [Xr(Lr([["0", "7"]]), Fe, qr()), ei(qr())] },
+		decimal_number: { rules: [
+			Xr(["_", Hr], i),
+			Xr(".", i, Kr("decimal_fraction")),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		decimal_fraction: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["e", "E"], i, Kr("exponent_sign")),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		exponent_sign: { rules: [
+			Xr(["+", "-"], i, Kr("exponent_digits")),
+			Xr(Hr, i, Kr("exponent_digits")),
+			ei(qr())
+		] },
+		exponent_digits: { rules: [
+			Xr(["_", Hr], i),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		hex_number: { rules: [
+			Xr(["_", Wr], i),
+			Xr(".", i, Kr("hex_fraction")),
+			Xr(["p", "P"], i, Kr("hex_exponent_sign")),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		hex_fraction: { rules: [
+			Xr(["_", Wr], i),
+			Xr(["p", "P"], i, Kr("hex_exponent_sign")),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		hex_exponent_sign: { rules: [
+			Xr(["+", "-"], i, Kr("hex_exponent_digits")),
+			Xr(Hr, i, Kr("hex_exponent_digits")),
+			ei(qr())
+		] },
+		hex_exponent_digits: { rules: [
+			Xr(["_", Hr], i),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		binary_number: { rules: [
+			Xr([
+				"_",
+				"0",
+				"1"
+			], i),
+			Xr("i", i, qr()),
+			ei(qr())
+		] },
+		octal_number: { rules: [
+			Xr(["_", Lr([["0", "7"]])], i),
+			Xr("i", i, qr()),
+			ei(qr())
+		] }
+	}
+});
+var P = 65;
+var F = 60;
+var I = 58;
+var L = Fr("identifier", "constant");
+var R = Un((e, t, n, r) => {
+	let i = n.indexOf("identifier"), a = n.indexOf("punctuation");
+	if (i < 0 || a < 0) return;
+	let o = n.indexOf("function");
+	o < 0 && (o = n.length, n.push("function"));
+	let s = $n(e, t, n), c = s.count, l = (e, t, n) => {
+		if (e < 0 || s.kind_of(e) !== a || s.text_of(e)[0] !== t) return null;
+		let r = 0;
+		for (let i = e; i < c; i++) {
+			if (s.is_trivia(i) || s.kind_of(i) !== a) continue;
+			let e = s.text_of(i);
+			for (let a = 0; a < e.length; a++) {
+				let o = e[a];
+				if (o === t) r++;
+				else if (o === n && (r--, r === 0)) return {
+					idx: i,
+					offset: a + 1
+				};
+			}
+		}
+		return null;
+	}, u = (e) => {
+		let t = s.text_of(e.idx);
+		if (e.offset < t.length) return t[e.offset] === "(";
+		let n = s.next_non_trivia(e.idx + 1);
+		return n >= 0 && s.kind_of(n) === a && s.text_of(n).startsWith("(");
+	}, d = (e) => {
+		let t = s.next_non_trivia(e + 1);
+		if (t < 0 || s.kind_of(t) !== a) return !1;
+		let n = s.text_of(t);
+		if (n.startsWith("(")) return !0;
+		if (!n.startsWith("[")) return !1;
+		let r = l(t, "[", "]");
+		return r != null && u(r);
+	};
+	for (let e = 0; e < c; e++) s.kind_of(e) === i && d(e) && r.emit(e, o, I);
+});
+var z = Un((e, t, n, r) => {
+	let i = n.indexOf("identifier"), a = n.indexOf("keyword"), o = n.indexOf("punctuation"), s = n.indexOf("string");
+	if (i < 0 || a < 0) return;
+	let c = n.indexOf("namespace");
+	c < 0 && (c = n.length, n.push("namespace"));
+	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 === "package") {
+			let t = l.next_non_trivia(e + 1);
+			t >= 0 && l.kind_of(t) === i && r.emit(t, c, P);
+			continue;
+		}
+		if (t === "import" && s >= 0 && o >= 0) {
+			let t = l.next_non_trivia(e + 1), n = !1;
+			for (t >= 0 && l.kind_of(t) === o && l.text_of(t) === "(" && (n = !0, t = l.next_non_trivia(t + 1)); t >= 0 && t < u;) {
+				let e = l.kind_of(t), a = l.text_of(t);
+				if (e === o && a === ")") break;
+				if (e === o && a === ";") {
+					if (!n) break;
+					t = l.next_non_trivia(t + 1);
+					continue;
+				}
+				if (e === i) {
+					let e = l.next_non_trivia(t + 1);
+					if (e >= 0 && l.kind_of(e) === s) {
+						r.emit(t, c, P), t = l.next_non_trivia(e + 1);
+						continue;
+					}
+					if (!n) break;
+				}
+				if (e === s) {
+					t = l.next_non_trivia(t + 1);
+					continue;
+				}
+				if (n) t++;
+				else break;
+			}
+		}
+	}
+});
+var B = {
+	into: "p",
+	strategy: "carry_pending",
+	find_open: "scan"
+};
+var V = ot(it("identifier"), it("function"));
+var H = jn([{
+	anchor: it("keyword", "func"),
+	when: ot(at(V, ft(B)), at(ft(B), st(at(V, ft(B))))),
+	rewrite: { p: "parameter" },
+	precedence: F
+}], { trivia: ["comment"] });
+var U = [
+	Vn(z, ["namespace"]),
+	Vn(H, ["parameter"]),
+	Vn(R, ["function"]),
+	Vn(L, ["constant"])
+];
+var W = _(N);
+var G = qn(W, U);
+function K(e) {
+	let t = G(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { W as grammar, K as language, N as raw_grammar, U as reclassifiers, G as tokenize };

package/dist/dist-GmbcGEAc.mjs

@@ -0,0 +1,3 @@
+import { P as Ye, Q as rt, R as bt, u as Be, z as ct } from "./dist-BQzCbTko.mjs";
+import { a as R, i as Q, n as B, o as Z, r as Ne, t as $ } from "./dist-BWcWG5YB.mjs";
+export { Ye as claim_property_scope, Be as function_variable_rules, Q as grammar, Ne as language, R as raw_grammar, Z as reclassifiers, bt as scan_embedded_groups, ct as scan_jsdoc, rt as scan_tagged_template, $ as tokenize, B as ts_frame_track };