comarkserv 0.1.0

package/dist/dist-BiVw4ojz.mjs

@@ -0,0 +1,592 @@
+import { A as Wr, D as Ur, F as Zr, G as ge$1, I as at, K as it, M as Xr, O as Vn, Q as ot, S as Qr, V as ei, Y as lt, d as Ir, et as qn, ft as zr, g as Mr, h as Lr, i as Br, it as st, l as Hn, m as Kr, mt as g, n as $n, o as Fr, pt as _, q as jn, r as $r, s as Gr, tt as qr, u as Hr, v as Nr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, P as be$1, d as Ie, et as n, j as a, nt as o, ot as r, s as Fe, ut as t } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+python@0.1.4/node_modules/@twinkleplop/python/dist/index.js
+function T(e) {
+	if (e === "") return [""];
+	let t = T(e.slice(1)), n = e[0].toLowerCase(), r = e[0].toUpperCase();
+	return n === r ? t.map((e) => n + e) : [...t.map((e) => n + e), ...t.map((e) => r + e)];
+}
+function E(e) {
+	let t = [];
+	for (let n of e) t.push(...T(n));
+	return t;
+}
+var D = E(["b", "u"]);
+var O = E([
+	"r",
+	"rb",
+	"br"
+]);
+var k = [...D, ...O];
+var A = E(["f", "t"]);
+var j = E([
+	"rf",
+	"fr",
+	"rt",
+	"tr"
+]);
+var M = [...A, ...j];
+var N = [...M, ...k];
+var se = N.filter((e) => e[0] >= "a" && e[0] <= "z");
+var ce = N.filter((e) => e[0] >= "A" && e[0] <= "Z");
+var le = ["\"\"\""];
+var ue = ["'''"];
+var de = ["\""];
+var fe = ["'"];
+var pe = /* @__PURE__ */ "and.as.assert.async.await.break.class.continue.def.del.elif.else.except.finally.for.from.global.if.import.in.is.lambda.nonlocal.not.or.pass.raise.return.try.while.with.yield".split(".");
+var P = ["True", "False"];
+var F = ["None"];
+var I = [
+	"int",
+	"float",
+	"complex",
+	"bool",
+	"str",
+	"bytes",
+	"bytearray",
+	"memoryview",
+	"list",
+	"tuple",
+	"dict",
+	"set",
+	"frozenset",
+	"object",
+	"range",
+	"slice",
+	"type"
+];
+var L = [
+	"**=",
+	"//=",
+	"<<=",
+	">>=",
+	"..."
+];
+var R = [
+	"**",
+	"//",
+	"<<",
+	">>",
+	"<=",
+	">=",
+	"==",
+	"!=",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&=",
+	"|=",
+	"^=",
+	"@=",
+	":=",
+	"->"
+];
+var z = [
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"&",
+	"|",
+	"^",
+	"~",
+	"<",
+	">",
+	"=",
+	"@"
+];
+var B = [
+	...L,
+	...R,
+	...z
+];
+var me = [
+	"(",
+	"[",
+	"{"
+];
+var he = [
+	")",
+	"]",
+	"}"
+];
+var V = Lr([[128, 65535]]);
+var H = Zr([
+	" ",
+	"	",
+	"\n",
+	"\r",
+	"\f"
+]);
+var U = $r("#", "\n", t);
+var W = Xr("\\", a);
+var G = [
+	Zr(M, Gr("fstring_prefix_probe")),
+	Zr(k, Gr("plain_prefix_probe")),
+	Xr(le, c, Gr("string_triple_dq")),
+	Xr(ue, c, Gr("string_triple_sq")),
+	Xr(de, c, Gr("string_single_dq")),
+	Xr(fe, c, Gr("string_single_sq"))
+];
+var K = [
+	Xr(["0x", "0X"], i, Gr("hex_number")),
+	Xr(["0b", "0B"], i, Gr("bin_number")),
+	Xr(["0o", "0O"], i, Gr("oct_number")),
+	Xr(Hr, i, Gr("number"))
+];
+var q = [Qr(F), Qr(pe)];
+var J = Xr(Br, n, Gr("type_identifier_body"));
+var Y = Xr([
+	"_",
+	zr,
+	V
+], n, Gr("identifier_body"));
+var X = g({
+	name: "python",
+	states: {
+		main: { rules: [
+			H,
+			U,
+			...G,
+			...K,
+			...q,
+			Xr(B, a),
+			W,
+			Xr([
+				"(",
+				")",
+				"[",
+				"]",
+				"{",
+				"}",
+				",",
+				";",
+				":",
+				"."
+			], o),
+			J,
+			Y
+		] },
+		identifier_body: { rules: [Xr([
+			"_",
+			Ur,
+			V
+		], n), ei(qr())] },
+		type_identifier_body: { rules: [Xr([
+			"_",
+			Ur,
+			V
+		], n), ei(qr())] },
+		number: { rules: [
+			Xr(["_", Hr], i),
+			Xr(".", i, Gr("float_decimal")),
+			Xr(["e", "E"], i, Gr("float_exponent_sign")),
+			Xr(["j", "J"], i, qr()),
+			ei(qr())
+		] },
+		float_decimal: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["e", "E"], i, Gr("float_exponent_sign")),
+			Xr(["j", "J"], i, qr()),
+			ei(qr())
+		] },
+		float_exponent_sign: { rules: [
+			Xr(["+", "-"], i, Gr("float_exponent_digits")),
+			Xr(Hr, i, Gr("float_exponent_digits")),
+			ei(qr())
+		] },
+		float_exponent_digits: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["j", "J"], i, qr()),
+			ei(qr())
+		] },
+		hex_number: { rules: [Xr(["_", Wr], i), ei(qr())] },
+		bin_number: { rules: [Xr([
+			"_",
+			"0",
+			"1"
+		], i), ei(qr())] },
+		oct_number: { rules: [Xr(["_", Lr([["0", "7"]])], i), ei(qr())] },
+		string_single_dq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		string_single_sq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		string_triple_dq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("\"\"\"", c, qr()),
+			ei({ token: c })
+		] },
+		string_triple_sq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("'''", c, qr()),
+			ei({ token: c })
+		] },
+		rstring_single_dq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		rstring_single_sq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		rstring_triple_dq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("\"\"\"", c, qr()),
+			ei({ token: c })
+		] },
+		rstring_triple_sq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("'''", c, qr()),
+			ei({ token: c })
+		] },
+		raw_esc_consume: { rules: [ei({
+			token: c,
+			exit: !0
+		})] },
+		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("N", Fe, Kr("esc_named_open")),
+			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_named_open: { rules: [Xr("{", Fe, Kr("esc_named_body")), ei(qr())] },
+		esc_named_body: { rules: [
+			Xr("}", Fe, qr()),
+			Xr([
+				Ur,
+				"_",
+				" ",
+				"-"
+			], Fe),
+			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())] },
+		fstring_prefix_probe: {
+			mode: "probe",
+			fallback: "string_prefix_fallback",
+			rules: [Zr([
+				"\"\"\"",
+				"'''",
+				"\"",
+				"'"
+			], Gr("fstring_prefix_commit")), ei(Gr("string_prefix_fallback"))]
+		},
+		fstring_prefix_commit: { rules: [Xr(A, r, Kr("fstring_prefix_quote")), Xr(j, r, Kr("raw_fstring_prefix_quote"))] },
+		fstring_prefix_quote: { rules: [
+			Xr("\"\"\"", c, Kr("fstring_body_triple_dq")),
+			Xr("'''", c, Kr("fstring_body_triple_sq")),
+			Xr("\"", c, Kr("fstring_body_single_dq")),
+			Xr("'", c, Kr("fstring_body_single_sq"))
+		] },
+		raw_fstring_prefix_quote: { rules: [
+			Xr("\"\"\"", c, Kr("raw_fstring_body_triple_dq")),
+			Xr("'''", c, Kr("raw_fstring_body_triple_sq")),
+			Xr("\"", c, Kr("raw_fstring_body_single_dq")),
+			Xr("'", c, Kr("raw_fstring_body_single_sq"))
+		] },
+		plain_prefix_probe: {
+			mode: "probe",
+			fallback: "string_prefix_fallback",
+			rules: [Zr([
+				"\"\"\"",
+				"'''",
+				"\"",
+				"'"
+			], Gr("plain_prefix_commit")), ei(Gr("string_prefix_fallback"))]
+		},
+		plain_prefix_commit: { rules: [Xr(D, r, Kr("plain_prefix_quote")), Xr(O, r, Kr("raw_prefix_quote"))] },
+		plain_prefix_quote: { rules: [
+			Xr("\"\"\"", c, Kr("string_triple_dq")),
+			Xr("'''", c, Kr("string_triple_sq")),
+			Xr("\"", c, Kr("string_single_dq")),
+			Xr("'", c, Kr("string_single_sq"))
+		] },
+		raw_prefix_quote: { rules: [
+			Xr("\"\"\"", c, Kr("rstring_triple_dq")),
+			Xr("'''", c, Kr("rstring_triple_sq")),
+			Xr("\"", c, Kr("rstring_single_dq")),
+			Xr("'", c, Kr("rstring_single_sq"))
+		] },
+		string_prefix_fallback: { rules: [Xr(se, n, Kr("identifier_body")), Xr(ce, n, Kr("type_identifier_body"))] },
+		fstring_body_single_dq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		fstring_body_single_sq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		fstring_body_triple_dq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("\"\"\"", c, qr()),
+			ei({ token: c })
+		] },
+		fstring_body_triple_sq: { rules: [
+			Xr("\\", Fe, Gr("string_escape_start")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("'''", c, qr()),
+			ei({ token: c })
+		] },
+		raw_fstring_body_single_dq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		raw_fstring_body_single_sq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("'", c, qr()),
+			ei({ token: c })
+		] },
+		raw_fstring_body_triple_dq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("\"\"\"", c, qr()),
+			ei({ token: c })
+		] },
+		raw_fstring_body_triple_sq: { rules: [
+			Xr("\\", c, Gr("raw_esc_consume")),
+			Xr("{{", c),
+			Xr("}}", c),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("'''", c, qr()),
+			ei({ token: c })
+		] },
+		fstring_expr_top: { rules: [
+			H,
+			U,
+			...G,
+			...K,
+			Xr([
+				"!s",
+				"!r",
+				"!a"
+			], be$1),
+			Xr(B, a),
+			W,
+			Xr("}", be$1, qr()),
+			Xr(":", o, Kr("fstring_format_spec")),
+			Xr("{", o, Gr("fstring_expr_nested")),
+			Xr(["(", "["], o, Gr("fstring_expr_nested")),
+			Xr([")", "]"], o, qr()),
+			Xr([
+				",",
+				";",
+				"."
+			], o),
+			...q,
+			J,
+			Y
+		] },
+		fstring_expr_nested: { rules: [
+			H,
+			U,
+			...G,
+			...K,
+			Xr(B, a),
+			W,
+			Xr(he, o, qr()),
+			Xr(me, o, Gr("fstring_expr_nested")),
+			Xr([
+				",",
+				";",
+				".",
+				":"
+			], o),
+			...q,
+			J,
+			Y
+		] },
+		fstring_format_spec: { rules: [
+			Xr("{{", Ie),
+			Xr("}}", Ie),
+			Xr("{", be$1, Gr("fstring_expr_top")),
+			Xr("}", be$1, qr()),
+			ei({ token: Ie })
+		] }
+	}
+});
+var ge = Mr("identifier", "boolean", P);
+var _e = Mr("identifier", "builtin", I);
+var ve = Nr("identifier", "class_name");
+var ye = Fr("identifier", "constant");
+var be = [{
+	anchor: it("identifier", "type"),
+	when: at(ot(it("class_name"), it("identifier")), st(lt("[", "]")), it("operator", "=")),
+	rewrite: "keyword"
+}];
+var xe = Ir("identifier", "function", { plain: !0 }, { trivia: ["comment"] });
+var Z = [
+	Vn(ge, ["boolean"]),
+	Vn(_e, ["builtin"]),
+	Vn(ye, ["constant"]),
+	Vn(ve, ["class_name"]),
+	Hn(jn(be, { trivia: ["comment"] }), "type_claim"),
+	Vn((e, t) => {
+		let { tokens: n, token_types: r } = t, i = r.indexOf("identifier"), a = r.indexOf("keyword"), o = r.indexOf("punctuation");
+		if (i < 0 || a < 0 || o < 0) return t;
+		let s = r.indexOf("namespace");
+		s < 0 && (s = r.length, r.push("namespace"));
+		let c = $n(e, n, r), l = c.count, u = (e) => {
+			let t = e;
+			for (; t >= 0 && t < l;) {
+				if (c.is_trivia(t)) {
+					t++;
+					continue;
+				}
+				let e = c.kind_of(t);
+				if (e === i) {
+					n[t * 3] = s, t++;
+					continue;
+				}
+				if (e === o && c.text_of(t) === ".") {
+					t++;
+					continue;
+				}
+				break;
+			}
+			return t;
+		};
+		for (let e = 0; e < l; e++) {
+			if (c.is_trivia(e) || c.kind_of(e) !== a) continue;
+			let t = c.text_of(e);
+			if (t === "import") {
+				let t = c.next_non_trivia(e + 1);
+				for (; t >= 0 && t < l && (t = u(t), t = c.next_non_trivia(t), !(t < 0));) {
+					if (c.kind_of(t) === a && c.text_of(t) === "as" && (t = c.next_non_trivia(t + 1), t >= 0 && c.kind_of(t) === i && (n[t * 3] = s, t = c.next_non_trivia(t + 1))), t >= 0 && c.kind_of(t) === o && c.text_of(t) === ",") {
+						t = c.next_non_trivia(t + 1);
+						continue;
+					}
+					break;
+				}
+				continue;
+			}
+			if (t === "from") {
+				let t = c.next_non_trivia(e + 1);
+				t = u(t), t >= 0 && c.kind_of(t) === a && c.text_of(t) === "import" && (e = t);
+				continue;
+			}
+		}
+		return {
+			tokens: n,
+			token_types: r
+		};
+	}, ["namespace"]),
+	Vn((e, t) => {
+		let { tokens: n, token_types: r } = t, i = r.indexOf("identifier"), a = r.indexOf("keyword"), o = r.indexOf("punctuation"), s = r.indexOf("operator");
+		if (i < 0 || a < 0 || o < 0) return t;
+		let c = r.indexOf("parameter");
+		c < 0 && (c = r.length, r.push("parameter"));
+		let l = $n(e, n, r), u = l.count, d = (e) => {
+			let t = 1, r = !0, a = e + 1;
+			for (; a < u && t > 0;) {
+				if (l.is_trivia(a)) {
+					a++;
+					continue;
+				}
+				let e = l.kind_of(a), u = l.text_of(a);
+				if (e === o) {
+					for (let e of u) if (e === "(" || e === "[") t++;
+					else if (e === ")" || e === "]") {
+						if (t--, t === 0) return a + 1;
+					} else e === "," && t === 1 && (r = !0);
+					a++;
+					continue;
+				}
+				t === 1 && r && e === i ? (n[a * 3] = c, r = !1) : e === s && (u === "*" || u === "**") || (r = !1), a++;
+			}
+			return a;
+		};
+		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 === "def") {
+				let t = l.next_non_trivia(e + 1);
+				if (t < 0 || l.kind_of(t) !== i || (t = l.next_non_trivia(t + 1), t < 0 || l.kind_of(t) !== o || !l.text_of(t).startsWith("("))) continue;
+				e = d(t) - 1;
+				continue;
+			}
+			if (t === "lambda") {
+				let t = !0, r = l.next_non_trivia(e + 1);
+				for (; r < u;) {
+					if (l.is_trivia(r)) {
+						r++;
+						continue;
+					}
+					let e = l.kind_of(r), a = l.text_of(r);
+					if (e === s && a === ":") break;
+					if (e === o && (a === "," || a === "(" || a === ")")) {
+						a === "," && (t = !0), r++;
+						continue;
+					}
+					e === i && t && (n[r * 3] = c, t = !1), r++;
+				}
+				e = r;
+			}
+		}
+		return {
+			tokens: n,
+			token_types: r
+		};
+	}, ["parameter"]),
+	Vn(xe, ["function"])
+];
+var Q = _(X);
+var $ = qn(Q, Z);
+function Se(e) {
+	let t = $(e);
+	return (e, n) => ge$1(e, t(e), n);
+}
+//#endregion
+export { Q as grammar, Se as language, X as raw_grammar, Z as reclassifiers, $ as tokenize };