comarkserv 0.1.0

package/dist/dist-fh99cWMN.mjs

@@ -0,0 +1,524 @@
+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, Q as ot, S as Qr, V as ei, Y as lt, et as qn, ft as zr, g as Mr, h as Lr, i as Br, k as Vr, 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, ut as yr, v as Nr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, L as d, V as f, W as h, et as n, ft as u, j as a, m as Le, nt as o, s as Fe, ut as t } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+rust@0.1.4/node_modules/@twinkleplop/rust/dist/index.js
+var te = /* @__PURE__ */ "if.else.match.loop.while.for.break.continue.return.fn.let.const.static.struct.enum.trait.impl.type.mod.use.extern.crate.pub.mut.ref.move.async.await.unsafe.dyn.as.in.where.self.super.Self.abstract.become.box.do.final.macro.override.priv.try.typeof.unsized.virtual.yield".split(".");
+var ne = ["true", "false"];
+var j = [
+	"<<=",
+	">>=",
+	"..="
+];
+var M = [
+	"::",
+	"->",
+	"=>",
+	"..",
+	"<<",
+	">>",
+	"<=",
+	">=",
+	"==",
+	"!=",
+	"&&",
+	"||",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&=",
+	"|=",
+	"^="
+];
+var N = [
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"&",
+	"|",
+	"^",
+	"!",
+	"<",
+	">",
+	"=",
+	".",
+	"?",
+	"~",
+	"@"
+];
+var P = [
+	...j,
+	...M,
+	...N
+];
+var F = [
+	"i8",
+	"i16",
+	"i32",
+	"i64",
+	"i128",
+	"isize",
+	"u8",
+	"u16",
+	"u32",
+	"u64",
+	"u128",
+	"usize"
+];
+var I = ["f32", "f64"];
+var L = [...F, ...I];
+var R = [
+	...F,
+	...I,
+	"bool",
+	"char",
+	"str"
+];
+var z = $r("//", "\n", t);
+$r("\"", "\"", c, { escape: "\\" });
+var B = g({
+	name: "rust",
+	states: {
+		main: { rules: [
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			z,
+			Xr("/*", t, Gr("block_comment")),
+			Xr("r###\"", c, Gr("raw_string_3")),
+			Xr("r##\"", c, Gr("raw_string_2")),
+			Xr("r#\"", c, Gr("raw_string_1")),
+			Xr("r\"", c, Gr("raw_string_0")),
+			Xr("br###\"", c, Gr("raw_string_3")),
+			Xr("br##\"", c, Gr("raw_string_2")),
+			Xr("br#\"", c, Gr("raw_string_1")),
+			Xr("br\"", c, Gr("raw_string_0")),
+			Xr("cr###\"", c, Gr("raw_string_3")),
+			Xr("cr##\"", c, Gr("raw_string_2")),
+			Xr("cr#\"", c, Gr("raw_string_1")),
+			Xr("cr\"", c, Gr("raw_string_0")),
+			Xr("b\"", c, Gr("string_body")),
+			Xr("c\"", c, Gr("string_body")),
+			Xr("\"", c, Gr("string_body")),
+			Xr("b'", c, Gr("char_body")),
+			Zr("'", Gr("quote_probe")),
+			Xr("#!", Le, Gr("attribute_open")),
+			Xr("#", Le, Gr("attribute_open")),
+			Xr([
+				"{",
+				"}",
+				"(",
+				")",
+				"[",
+				"]",
+				";",
+				","
+			], o),
+			Xr("::", o),
+			Xr(":", o),
+			Xr(P, a),
+			Qr(te),
+			Xr(["0x", "0X"], i, Gr("hex_number")),
+			Xr(["0o", "0O"], i, Gr("octal_number")),
+			Xr(["0b", "0B"], i, Gr("binary_number")),
+			Xr(Hr, i, Gr("number")),
+			Xr(Br, n, Gr("type_identifier")),
+			Xr(["_", zr], n, Gr("identifier"))
+		] },
+		identifier: { rules: [
+			Xr(["_", Ur], n),
+			Xr("!", d, qr()),
+			ei(qr())
+		] },
+		type_identifier: { rules: [
+			Xr(["_", Ur], n),
+			Xr("!", d, qr()),
+			ei(qr())
+		] },
+		block_comment: { rules: [
+			Xr("/*", t, Gr("block_comment")),
+			Xr("*/", t, qr()),
+			ei({ token: t })
+		] },
+		string_body: { rules: [
+			Xr("\\u{", Fe, Gr("esc_unicode")),
+			Xr("\\x", Fe, Gr("esc_hex")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		raw_string_0: { rules: [Xr("\"", c, qr()), ei({ token: c })] },
+		raw_string_1: { rules: [Xr("\"#", c, qr()), ei({ token: c })] },
+		raw_string_2: { rules: [Xr("\"##", c, qr()), ei({ token: c })] },
+		raw_string_3: { rules: [Xr("\"###", c, qr()), ei({ token: c })] },
+		quote_probe: {
+			mode: "probe",
+			fallback: "char_literal",
+			rules: [
+				Zr(["_", Vr], Gr("quote_probe_ident")),
+				Zr("\\", Gr("char_literal")),
+				Zr("'", Gr("char_literal")),
+				Zr([
+					" ",
+					"	",
+					"\n",
+					"\r",
+					",",
+					";",
+					":",
+					".",
+					">",
+					")",
+					"]",
+					"}",
+					"+",
+					"-",
+					"*",
+					"/",
+					"%",
+					"&",
+					"|",
+					"^",
+					"!",
+					"=",
+					"<",
+					"?",
+					"(",
+					"[",
+					"{",
+					"#",
+					"@",
+					"~",
+					Hr
+				], Gr("char_literal"))
+			]
+		},
+		quote_probe_ident: {
+			mode: "probe",
+			fallback: "lifetime_token",
+			rules: [Zr("'", Gr("char_literal")), Zr(/* @__PURE__ */ " 	\n\r,;:.>)]}+-*/%&|^!=<?([{#@~".split(""), Gr("lifetime_token"))]
+		},
+		char_literal: { rules: [Xr("'", c, Kr("char_literal_body")), ei(qr())] },
+		char_literal_body: { rules: [
+			Xr("\\u{", Fe, Gr("esc_unicode")),
+			Xr("\\x", Fe, Gr("esc_hex")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("'", c, qr()),
+			ei({
+				token: c,
+				...Kr("char_literal_close")
+			})
+		] },
+		esc_simple: { rules: [ei({
+			token: Fe,
+			exit: !0
+		})] },
+		esc_unicode: { rules: [
+			Xr(Wr, Fe),
+			Xr("_", Fe),
+			Xr("}", Fe, qr()),
+			ei(qr())
+		] },
+		esc_hex: { rules: [Xr(Wr, Fe), ei(qr())] },
+		char_literal_close: { rules: [Xr("'", c, qr()), ei(qr())] },
+		lifetime_token: { rules: [Xr("'", o, Kr("lifetime_body")), ei(qr())] },
+		lifetime_body: { rules: [Xr(["_", Ur], h), ei(qr())] },
+		char_body: { rules: [
+			Xr("\\u{", Fe, Gr("esc_unicode")),
+			Xr("\\x", Fe, Gr("esc_hex")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("'", c, qr()),
+			ei({
+				token: c,
+				...Kr("char_literal_close")
+			})
+		] },
+		attribute_open: { rules: [Xr("[", o, Kr("attribute_body")), ei(qr())] },
+		attribute_body: { rules: [
+			Xr("]", o, qr()),
+			Xr("(", o, Gr("attribute_parens")),
+			Xr("[", o, Gr("attribute_brackets")),
+			Xr([",", "="], o),
+			$r("\"", "\"", c, { escape: "\\" }),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr(["_", Ur], u),
+			Xr(["-", ":"], u)
+		] },
+		attribute_parens: { rules: [
+			Xr(")", o, qr()),
+			Xr("(", o, Gr("attribute_parens")),
+			Xr([",", "="], o),
+			$r("\"", "\"", c, { escape: "\\" }),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr(["_", Ur], u),
+			Xr(["-", ":"], u)
+		] },
+		attribute_brackets: { rules: [
+			Xr("]", o, qr()),
+			Xr("[", o, Gr("attribute_brackets")),
+			Xr([",", "="], o),
+			$r("\"", "\"", c, { escape: "\\" }),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr(["_", Ur], u),
+			Xr(["-", ":"], u)
+		] },
+		number: { rules: [
+			Xr(["_", Hr], i),
+			Xr("..", a, qr()),
+			Xr(".", i, Kr("decimal")),
+			Xr(["e", "E"], a, Kr("exponent_sign")),
+			Qr(L, qr(), f),
+			ei(qr())
+		] },
+		decimal: { rules: [
+			Xr(["_", Hr], i),
+			Xr(["e", "E"], a, Kr("exponent_sign")),
+			Qr(I, qr(), f),
+			ei(qr())
+		] },
+		exponent_sign: { rules: [
+			Xr(["+", "-"], i, Kr("exponent_digits")),
+			Xr(Hr, i, Kr("exponent_digits")),
+			ei(qr())
+		] },
+		exponent_digits: { rules: [
+			Xr(["_", Hr], i),
+			Qr(I, qr(), f),
+			ei(qr())
+		] },
+		hex_number: { rules: [
+			Xr(["_", Wr], i),
+			Qr(F, qr(), f),
+			ei(qr())
+		] },
+		octal_number: { rules: [
+			Xr(["_", Lr([["0", "7"]])], i),
+			Qr(F, qr(), f),
+			ei(qr())
+		] },
+		binary_number: { rules: [
+			Xr([
+				"_",
+				"0",
+				"1"
+			], i),
+			Qr(F, qr(), f),
+			ei(qr())
+		] }
+	}
+});
+var V = Mr("identifier", "boolean", ne);
+var H = Mr("identifier", "class_name", R);
+var U = Nr("identifier", "class_name");
+var W = Fr("identifier", "constant");
+var G = (e, t) => {
+	let { tokens: n, token_types: r } = t, i = r.indexOf("identifier"), a = r.indexOf("class_name"), o = r.indexOf("namespace"), s = r.indexOf("keyword"), c = r.indexOf("punctuation");
+	if (i < 0 || s < 0 || c < 0) return t;
+	let l = r.indexOf("variant");
+	l < 0 && (l = r.length, r.push("variant"));
+	let u = $n(e, n, r), d = u.count, f = (e) => e === i || e === a || o >= 0 && e === o, p = (t) => {
+		let r = n[t * 3 + 1];
+		if (n[t * 3 + 2] <= r) return !1;
+		let i = e.charCodeAt(r);
+		return i >= 65 && i <= 90;
+	}, m = new Uint8Array(d);
+	for (let e = 0; e < d; e++) if (!u.is_trivia(e) && u.kind_of(e) === s && u.text_of(e) === "use") for (let t = e; t < d && (m[t] = 1, !(u.kind_of(t) === c && u.text_of(t) === ";")); t++);
+	for (let e = 0; e < d - 2; e++) {
+		if (m[e] || u.is_trivia(e) || !f(u.kind_of(e)) || !p(e)) continue;
+		let t = u.next_non_trivia(e + 1);
+		if (t < 0 || u.kind_of(t) !== c || !u.text_of(t).startsWith("::")) continue;
+		let r = u.next_non_trivia(t + 1);
+		r < 0 || !f(u.kind_of(r)) || !p(r) || (n[r * 3] = l);
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+};
+var K = (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;
+	for (let e = 0; e < u; e++) {
+		if (l.is_trivia(e) || l.kind_of(e) !== a || l.text_of(e) !== "fn") continue;
+		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) === s && l.text_of(t) === "<") {
+			let e = 1;
+			for (t++; t < u && e > 0;) {
+				if (l.is_trivia(t)) {
+					t++;
+					continue;
+				}
+				if (l.kind_of(t) === s) {
+					let n = l.text_of(t);
+					n === "<" ? e++ : n === ">" ? e-- : n === ">>" && (e = Math.max(0, e - 2));
+				}
+				t++;
+			}
+		}
+		if (t = l.next_non_trivia(t), t < 0 || l.kind_of(t) !== o || !l.text_of(t).startsWith("(")) continue;
+		let r = 1, d = !0, f = t + 1;
+		for (; f < u && r > 0;) {
+			if (l.is_trivia(f)) {
+				f++;
+				continue;
+			}
+			let e = l.kind_of(f), t = l.text_of(f);
+			if (e === o) {
+				for (let e of t) if (e === "(" || e === "[" || e === "{") r++;
+				else if (e === ")" || e === "]" || e === "}") {
+					if (r--, r === 0) break;
+				} else e === "," && r === 1 && (d = !0);
+				f++;
+				continue;
+			}
+			if (r === 1 && d) {
+				if (e === a && (t === "self" || t === "mut")) {
+					f++;
+					continue;
+				}
+				if (e === s && t === "&") {
+					f++;
+					continue;
+				}
+				e === i && (n[f * 3] = c), d = !1;
+			}
+			f++;
+		}
+		e = f - 1;
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+};
+var q = (e, t) => {
+	let { tokens: n, token_types: r } = t, i = r.indexOf("identifier"), a = r.indexOf("keyword"), o = r.indexOf("punctuation"), s = r.indexOf("class_name");
+	if (i < 0 || a < 0 || o < 0) return t;
+	let c = r.indexOf("namespace");
+	c < 0 && (c = r.length, r.push("namespace"));
+	let l = $n(e, n, r), u = l.count;
+	for (let e = 0; e < u; e++) if (!l.is_trivia(e) && l.kind_of(e) === a && l.text_of(e) === "use") for (let t = e + 1; t < u; t++) {
+		if (l.is_trivia(t)) continue;
+		let e = l.kind_of(t);
+		if (e === o && l.text_of(t) === ";") break;
+		if (e !== i && e !== s) continue;
+		let r = l.next_non_trivia(t + 1);
+		r >= 0 && l.kind_of(r) === o && l.text_of(r).startsWith("::") && (n[t * 3] = c);
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+};
+var J = lt("(", ")");
+var Y = [{
+	anchor: "identifier",
+	when: ot(at(J), at(it("builtin", ["!"]), J), at(lt("<", ">"), J), at(it("punctuation", ["::"]), lt("<", ">"), J)),
+	rewrite: "function"
+}];
+var X = /* @__PURE__ */ new Set(["impl", "for"]);
+var re = /* @__PURE__ */ new Set([
+	"fn",
+	"impl",
+	"for"
+]);
+var ie = () => (e, t) => {
+	let n = new Uint32Array(t.tokens), r = t.token_types.slice(), i = r.indexOf("operator"), a = r.indexOf("punctuation"), o = r.indexOf("class_name"), s = r.indexOf("keyword"), c = r.indexOf("identifier");
+	if (i === -1 || a === -1) return {
+		tokens: n,
+		token_types: r
+	};
+	let l = $n(e, n, r), u = l.count, d = (e) => {
+		let t = l.prev_non_trivia(e - 1);
+		if (t < 0) return !1;
+		let n = l.kind_of(t);
+		if (n === o || n === a && l.text_of(t) === "::") return !0;
+		if (n === s) return X.has(l.text_of(t));
+		if (n === c) {
+			let e = l.prev_non_trivia(t - 1);
+			return e < 0 || l.kind_of(e) !== s ? !1 : re.has(l.text_of(e));
+		}
+		return !1;
+	}, f = (e) => {
+		let t = 1;
+		for (let n = e + 1; n < u; n++) {
+			if (l.kind_of(n) !== i) continue;
+			let e = l.text_of(n);
+			if (e === "<") t++;
+			else if (e === ">") {
+				if (t--, t === 0) return n;
+			} else if (e === ">>") {
+				if (t -= 2, t <= 0) return n;
+			} else if (e === ">=" || e === ">>=" || e === "<=" || e === "<<" || e === "<<=") return -1;
+		}
+		return -1;
+	};
+	for (let e = 0; e < u; e++) {
+		if (l.kind_of(e) !== i || l.text_of(e) !== "<" || !d(e)) continue;
+		let t = f(e);
+		if (t !== -1) {
+			for (let r = e; r <= t; r++) {
+				if (l.kind_of(r) !== i) continue;
+				let e = l.text_of(r);
+				(e === "<" || e === ">" || e === ">>") && (n[r * 3] = a);
+			}
+			e = t;
+		}
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+};
+var ae = yr({
+	anchor_type: "lifetime",
+	consume_next_types: ["identifier", "class_name"],
+	refuse_if: {
+		offset: 2,
+		type_must_be: "punctuation",
+		first_char_in: "("
+	}
+});
+var Z = [
+	Vn(V, ["boolean"]),
+	Vn(H, ["class_name"]),
+	Vn(W, ["constant"]),
+	Vn(U, ["class_name"]),
+	Vn(q, ["namespace"]),
+	Vn(G, ["variant"]),
+	Vn(K, ["parameter"]),
+	Hn(ie(), "type_claim"),
+	Vn(jn(Y, { trivia: ["comment"] }), ["function"]),
+	Vn(ae, ["lifetime"], "shape")
+];
+var Q = _(B);
+var $ = qn(Q, Z);
+function oe(e) {
+	let t = $(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { Q as grammar, oe as language, B as raw_grammar, Z as reclassifiers, $ as tokenize };