comarkserv 0.1.0

package/dist/dist-CXQ7eTfT.mjs

@@ -0,0 +1,417 @@
+import { A as Wr, F as Zr, G as ge, M as Xr, O as Vn, V as ei, et as qn, k as Vr, m as Kr, mt as g$1, pt as _$1, r as $r, s as Gr, tt as qr, u as Hr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { F as c, G as i, N as b$1, 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+yaml@0.1.4/node_modules/@twinkleplop/yaml/dist/index.js
+var g = [" ", "	"];
+var _ = ["\n", "\r"];
+var v = [...g, ..._];
+var y = [
+	Vr,
+	Hr,
+	"_",
+	"-",
+	".",
+	"/",
+	":",
+	"@",
+	"$",
+	"#",
+	"!",
+	"%",
+	"?",
+	"+",
+	"=",
+	"~",
+	"'",
+	"(",
+	")"
+];
+var b = [
+	Vr,
+	Hr,
+	"_",
+	"-",
+	".",
+	"/",
+	":",
+	"@",
+	"$",
+	"#",
+	"+",
+	"=",
+	"~",
+	"'",
+	"(",
+	")",
+	"?",
+	"&",
+	";",
+	"*",
+	"%",
+	"!"
+];
+var x = $r("#", "\n", t, { multiline: !1 });
+var S = Xr("\"", c, Gr("double_string_body"));
+var C = $r("'", "'", c);
+var w = Zr(g);
+var T = Zr(_);
+var E = Xr(["@", "`"], o);
+var D = [
+	w,
+	T,
+	x,
+	S,
+	C,
+	Xr(["---", "..."], o),
+	Xr("&", b$1, Gr("anchor_body")),
+	Xr("*", b$1, Gr("alias_body")),
+	Xr(["!!", "!"], a, Gr("tag_body")),
+	Xr("[", o, Gr("flow_seq")),
+	Xr("{", o, Gr("flow_map"))
+];
+var O = g$1({
+	name: "yaml",
+	states: {
+		main: { rules: [
+			...D,
+			Xr("|", a, Gr("literal_header")),
+			Xr(">", a, Gr("folded_header")),
+			Xr("%", a, Gr("directive_name")),
+			Xr([":", ","], o),
+			Zr("-", Gr("dash_probe")),
+			Zr("?", Gr("question_probe")),
+			E,
+			ei({
+				token: n,
+				state: "plain_scalar"
+			})
+		] },
+		flow_seq: { rules: [
+			...D,
+			Xr("]", o, qr()),
+			Xr("}", o, qr()),
+			Xr([":", ","], o),
+			Zr("-", Gr("dash_probe_flow")),
+			Zr("?", Gr("question_probe_flow")),
+			E,
+			ei({
+				token: n,
+				state: "plain_scalar_flow"
+			})
+		] },
+		flow_map: { rules: [
+			...D,
+			Xr("}", o, qr()),
+			Xr("]", o, qr()),
+			Xr([":", ","], o),
+			Zr("-", Gr("dash_probe_flow")),
+			Zr("?", Gr("question_probe_flow")),
+			E,
+			ei({
+				token: n,
+				state: "plain_scalar_flow"
+			})
+		] },
+		plain_scalar: { rules: [
+			Zr(v, qr()),
+			Zr(":", Gr("colon_probe")),
+			ei({ token: n })
+		] },
+		plain_scalar_flow: { rules: [
+			Zr(v, qr()),
+			Zr(":", Gr("colon_probe")),
+			Zr([
+				",",
+				"[",
+				"]",
+				"{",
+				"}"
+			], qr()),
+			ei({ token: n })
+		] },
+		colon_probe: {
+			mode: "probe",
+			fallback: "colon_sep",
+			rules: [Zr(v, Kr("colon_sep")), ei(Kr("colon_scalar"))]
+		},
+		colon_sep: { rules: [Xr(":", o, qr())] },
+		colon_scalar: { rules: [Xr(":", n, Kr("plain_scalar"))] },
+		dash_probe: {
+			mode: "probe",
+			fallback: "dash_as_punct",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Gr("dash_as_punct")), ei(Gr("dash_as_scalar"))]
+		},
+		dash_as_punct: { rules: [Xr("-", o, qr())] },
+		dash_as_scalar: { rules: [Xr("-", n, Kr("plain_scalar"))] },
+		question_probe: {
+			mode: "probe",
+			fallback: "question_as_punct",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Gr("question_as_punct")), ei(Gr("question_as_scalar"))]
+		},
+		question_as_punct: { rules: [Xr("?", o, qr())] },
+		question_as_scalar: { rules: [Xr("?", n, Kr("plain_scalar"))] },
+		dash_probe_flow: {
+			mode: "probe",
+			fallback: "dash_as_punct",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Gr("dash_as_punct")), ei(Gr("dash_as_scalar_flow"))]
+		},
+		dash_as_scalar_flow: { rules: [Xr("-", n, Kr("plain_scalar_flow"))] },
+		question_probe_flow: {
+			mode: "probe",
+			fallback: "question_as_punct",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Gr("question_as_punct")), ei(Gr("question_as_scalar_flow"))]
+		},
+		question_as_scalar_flow: { rules: [Xr("?", n, Kr("plain_scalar_flow"))] },
+		anchor_body: { rules: [Xr(y, b$1), ei(qr())] },
+		alias_body: { rules: [Xr(y, b$1), ei(qr())] },
+		tag_body: { rules: [
+			Xr("<", a, Kr("tag_verbatim")),
+			Xr(b, r),
+			ei(qr())
+		] },
+		tag_verbatim: { rules: [Xr(">", a, qr()), ei({ token: r })] },
+		directive_name: { rules: [
+			Zr(g, Kr("directive_body")),
+			Zr(_, qr()),
+			Xr([
+				Vr,
+				Hr,
+				"_"
+			], r),
+			ei(Kr("directive_body"))
+		] },
+		directive_body: { rules: [
+			w,
+			Zr(_, qr()),
+			ei({ token: n })
+		] },
+		literal_header: { rules: [
+			Xr(["-", "+"], a),
+			Xr(Hr, i),
+			w,
+			x,
+			Zr("\n", Kr("literal_body")),
+			ei({ token: c })
+		] },
+		folded_header: { rules: [
+			Xr(["-", "+"], a),
+			Xr(Hr, i),
+			w,
+			x,
+			Zr("\n", Kr("folded_body")),
+			ei({ token: c })
+		] },
+		literal_body: { rules: [Zr("\n", Gr("literal_nl_probe")), ei({ token: c })] },
+		literal_nl_probe: {
+			mode: "probe",
+			fallback: "literal_nl_stay",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Kr("literal_nl_stay")), ei(Kr("literal_nl_exit"))]
+		},
+		literal_nl_stay: { rules: [Xr("\n", c, Kr("literal_body"))] },
+		literal_nl_exit: { rules: [Xr("\n", c, qr())] },
+		folded_body: { rules: [Zr("\n", Gr("folded_nl_probe")), ei({ token: c })] },
+		folded_nl_probe: {
+			mode: "probe",
+			fallback: "folded_nl_stay",
+			rules: [Zr([
+				...g,
+				"\n",
+				"\r"
+			], Kr("folded_nl_stay")), ei(Kr("folded_nl_exit"))]
+		},
+		folded_nl_stay: { rules: [Xr("\n", c, Kr("folded_body"))] },
+		folded_nl_exit: { rules: [Xr("\n", c, qr())] },
+		double_string_body: { rules: [
+			Xr("\\x", Fe, Gr("esc_hex_d1")),
+			Xr("\\u", Fe, Gr("esc_u4_d1")),
+			Xr("\\U", Fe, Gr("esc_u8_d1")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("\"", c, qr()),
+			ei({ token: c })
+		] },
+		esc_simple: { rules: [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())] }
+	}
+});
+var k = /* @__PURE__ */ new Set([
+	"true",
+	"True",
+	"TRUE",
+	"false",
+	"False",
+	"FALSE",
+	"yes",
+	"Yes",
+	"YES",
+	"no",
+	"No",
+	"NO",
+	"on",
+	"On",
+	"ON",
+	"off",
+	"Off",
+	"OFF",
+	"y",
+	"Y",
+	"n",
+	"N"
+]);
+var A = /* @__PURE__ */ new Set([
+	"null",
+	"Null",
+	"NULL",
+	"~"
+]);
+var j = /* @__PURE__ */ new Set([
+	".inf",
+	".Inf",
+	".INF"
+]);
+var M = /* @__PURE__ */ new Set([
+	".nan",
+	".NaN",
+	".NAN"
+]);
+var N = (e) => e >= "0" && e <= "9";
+var P = (e) => e >= "0" && e <= "9" || e >= "a" && e <= "f" || e >= "A" && e <= "F";
+var F = (e) => e >= "0" && e <= "7";
+function I(e) {
+	let t = e.length;
+	if (t === 0) return !1;
+	let n = 0, r = e[0], i = r === "+" || r === "-";
+	if (i && (n = 1), n === t) return !1;
+	if (e[n] === ".") {
+		let t = e.slice(n);
+		return j.has(t) || !i && M.has(t) ? !0 : L(e, n);
+	}
+	if (!i && e[n] === "0" && n + 1 < t) {
+		let r = e[n + 1];
+		if (r === "x") {
+			if (n + 2 === t) return !1;
+			for (let r = n + 2; r < t; r++) if (!P(e[r])) return !1;
+			return !0;
+		}
+		if (r === "o") {
+			if (n + 2 === t) return !1;
+			for (let r = n + 2; r < t; r++) if (!F(e[r])) return !1;
+			return !0;
+		}
+	}
+	return L(e, n);
+}
+function L(e, t) {
+	let n = e.length, r = t;
+	if (r === n) return !1;
+	let i = !1;
+	if (e[r] === ".") {
+		if (r++, r === n || !N(e[r])) return !1;
+		for (; r < n && N(e[r]);) i = !0, r++;
+	} else if (N(e[r])) {
+		for (; r < n && N(e[r]);) i = !0, r++;
+		if (r < n && e[r] === ".") for (r++; r < n && N(e[r]);) r++;
+	} else return !1;
+	if (!i) return !1;
+	if (r < n && (e[r] === "e" || e[r] === "E")) {
+		if (r++, r < n && (e[r] === "+" || e[r] === "-") && r++, r === n || !N(e[r])) return !1;
+		for (; r < n && N(e[r]);) r++;
+	}
+	return r === n;
+}
+var R = [Vn((e, t) => {
+	let n = new Uint32Array(t.tokens), r = t.token_types.slice(), i = n.length / 3;
+	if (i === 0) return {
+		tokens: n,
+		token_types: r
+	};
+	let a = r.indexOf("identifier");
+	if (a < 0) return {
+		tokens: n,
+		token_types: r
+	};
+	let o = (e) => {
+		let t = r.indexOf(e);
+		return t < 0 && (t = r.length, r.push(e)), t;
+	}, s = o("boolean"), c = o("null"), l = o("number");
+	for (let t = 0; t < i; t++) {
+		if (n[t * 3] !== a) continue;
+		let r = n[t * 3 + 1], i = n[t * 3 + 2], o = e.slice(r, i);
+		k.has(o) ? n[t * 3] = s : A.has(o) ? n[t * 3] = c : I(o) && (n[t * 3] = l);
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+}, [
+	"boolean",
+	"null",
+	"number"
+]), Vn((e, t) => {
+	let n = new Uint32Array(t.tokens), r = t.token_types.slice(), i = n.length / 3;
+	if (i === 0) return {
+		tokens: n,
+		token_types: r
+	};
+	let a = r.indexOf("identifier"), o = r.indexOf("punctuation"), s = r.indexOf("comment");
+	if (a < 0 || o < 0) return {
+		tokens: n,
+		token_types: r
+	};
+	let c = r.indexOf("property");
+	c < 0 && (c = r.length, r.push("property"));
+	for (let t = 0; t < i; t++) {
+		if (n[t * 3] !== a) continue;
+		let r = t + 1;
+		for (; r < i && n[r * 3] === s;) r++;
+		if (r >= i || n[r * 3] !== o) continue;
+		let l = n[r * 3 + 1];
+		n[r * 3 + 2] - l === 1 && e[l] === ":" && (n[t * 3] = c);
+	}
+	return {
+		tokens: n,
+		token_types: r
+	};
+}, ["property"])];
+var z = _$1(O);
+var B = qn(z, R);
+function V(e) {
+	let t = B(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { z as grammar, V as language, O as raw_grammar, R as reclassifiers, B as tokenize };