comarkserv 0.1.0

package/dist/dist-CsTXDvwi.mjs

@@ -0,0 +1,300 @@
+import { A as Wr, F as Zr, G as ge, M as Xr, S as Qr, V as ei, et as qn, h as Lr, k as Vr, m as Kr, mt as g, 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, j as a, mt as v$1, nt as o, ot as r, s as Fe, u as He, ut as t, z as e } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+toml@0.1.4/node_modules/@twinkleplop/toml/dist/index.js
+var _ = Zr([" ", "	"]);
+var v = Zr(["\n", "\r"]);
+var y = $r("#", "\n", t, { multiline: !1 });
+var b = Xr("\"", c, Gr("basic_string_body"));
+var x = $r("'", "'", c);
+var S = Xr("\"\"\"", c, Gr("ml_basic_string_body"));
+var C = $r("'''", "'''", c);
+var w = Xr("\"", v$1, Gr("basic_key_body"));
+var T = $r("'", "'", v$1);
+var E = Xr("\"\"\"", v$1, Gr("ml_basic_key_body"));
+var D = $r("'''", "'''", v$1);
+var O = Xr([
+	Vr,
+	Hr,
+	"-",
+	"_"
+], v$1);
+var k = [
+	S,
+	C,
+	b,
+	x
+];
+var A = Lr([["0", "7"]]);
+var j = Lr([["0", "1"]]);
+var M = (e) => ({
+	[`value_number_${e}`]: { rules: [
+		Xr(Hr, i),
+		Xr("_", i),
+		Xr(["x", "X"], i, Kr(`value_hex_${e}`)),
+		Xr(["o", "O"], i, Kr(`value_oct_${e}`)),
+		Xr(["b", "B"], i, Kr(`value_bin_${e}`)),
+		Xr(".", i, Kr(`value_decimal_${e}`)),
+		Xr(["e", "E"], i, Kr(`value_exp_sign_${e}`)),
+		ei(qr())
+	] },
+	[`value_hex_${e}`]: { rules: [
+		Xr(Wr, i),
+		Xr("_", i),
+		ei(qr())
+	] },
+	[`value_oct_${e}`]: { rules: [
+		Xr(A, i),
+		Xr("_", i),
+		ei(qr())
+	] },
+	[`value_bin_${e}`]: { rules: [
+		Xr(j, i),
+		Xr("_", i),
+		ei(qr())
+	] },
+	[`value_decimal_${e}`]: { rules: [
+		Xr(Hr, i),
+		Xr("_", i),
+		Xr(["e", "E"], i, Kr(`value_exp_sign_${e}`)),
+		ei(qr())
+	] },
+	[`value_exp_sign_${e}`]: { rules: [
+		Xr(["+", "-"], i, Kr(`value_exp_digits_${e}`)),
+		Xr(Hr, i, Kr(`value_exp_digits_${e}`)),
+		ei(qr())
+	] },
+	[`value_exp_digits_${e}`]: { rules: [
+		Xr(Hr, i),
+		Xr("_", i),
+		ei(qr())
+	] },
+	[`value_signed_${e}`]: { rules: [
+		Qr(["inf", "nan"], qr(), r),
+		Xr(Hr, i, Kr(`value_number_${e}`)),
+		ei(qr())
+	] }
+});
+var N = M("value");
+var P = M("value_array");
+var F = M("value_inline_table_after_val");
+var I = (e) => ({
+	[`digit_probe1_${e}`]: {
+		mode: "probe",
+		fallback: `number_from_probe_${e}`,
+		rules: [Zr(Hr, Gr(`digit_probe2_${e}`)), ei(Gr(`number_from_probe_${e}`))]
+	},
+	[`digit_probe2_${e}`]: {
+		mode: "probe",
+		fallback: `number_from_probe_${e}`,
+		rules: [
+			Zr(Hr, Gr(`digit_probe3_${e}`)),
+			Zr(":", Gr(`local_time_from_probe_${e}`)),
+			ei(Gr(`number_from_probe_${e}`))
+		]
+	},
+	[`digit_probe3_${e}`]: {
+		mode: "probe",
+		fallback: `number_from_probe_${e}`,
+		rules: [Zr(Hr, Gr(`digit_probe4_${e}`)), ei(Gr(`number_from_probe_${e}`))]
+	},
+	[`digit_probe4_${e}`]: {
+		mode: "probe",
+		fallback: `number_from_probe_${e}`,
+		rules: [
+			Zr("-", Gr(`datetime_from_probe_${e}`)),
+			Zr(".", Gr(`number_from_probe_${e}`)),
+			ei(Gr(`number_from_probe_${e}`))
+		]
+	},
+	[`number_from_probe_${e}`]: { rules: [Xr(Hr, i, Kr(`value_number_${e}`))] },
+	[`local_time_from_probe_${e}`]: { rules: [Xr(Hr, "datetime", Kr(`local_time_body_${e}`))] },
+	[`local_time_body_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr(":", o),
+		Xr(".", o),
+		ei(qr())
+	] },
+	[`datetime_from_probe_${e}`]: { rules: [Xr(Hr, "datetime", Kr(`dt_year_${e}`))] },
+	[`dt_year_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr("-", o, Kr(`dt_month_${e}`)),
+		ei(qr())
+	] },
+	[`dt_month_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr("-", o, Kr(`dt_day_${e}`)),
+		ei(qr())
+	] },
+	[`dt_day_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr([
+			"T",
+			"t",
+			" "
+		], "datetime", Kr(`dt_time_${e}`)),
+		ei(qr())
+	] },
+	[`dt_time_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr(":", o),
+		Xr(".", o),
+		Xr(["Z", "z"], "datetime", Kr(`dt_tz_${e}`)),
+		Xr(["+", "-"], o, Kr(`dt_offset_${e}`)),
+		ei(qr())
+	] },
+	[`dt_tz_${e}`]: { rules: [ei(qr())] },
+	[`dt_offset_${e}`]: { rules: [
+		Xr(Hr, "datetime"),
+		Xr(":", o),
+		ei(qr())
+	] }
+});
+var L = I("value");
+var R = I("value_array");
+var z = I("value_inline_table_after_val");
+var B = (e$1, t) => [
+	_,
+	...t ? [v, y] : [],
+	...k,
+	Qr(["true", "false"], {}, e),
+	Qr(["inf", "nan"], {}, r),
+	Xr(["+", "-"], a, Gr(`value_signed_${e$1}`)),
+	Zr(Hr, Gr(`digit_probe1_${e$1}`)),
+	Xr("[", o, Gr("value_array")),
+	Xr("{", o, Gr("value_inline_table"))
+];
+var V = {
+	...N,
+	...P,
+	...F
+};
+var H = {
+	...L,
+	...R,
+	...z
+};
+var U = g({
+	name: "toml",
+	states: {
+		root: { rules: [
+			_,
+			v,
+			y,
+			Zr("[", Gr("bracket_probe")),
+			E,
+			D,
+			w,
+			T,
+			O,
+			Xr("=", a, Kr("value")),
+			Xr(".", o)
+		] },
+		bracket_probe: {
+			mode: "probe",
+			fallback: "table_header",
+			rules: [Zr("[", Gr("array_table_header")), ei(Gr("table_header"))]
+		},
+		table_header: { rules: [Xr("[", o, Kr("table_header_key"))] },
+		table_header_key: { rules: [
+			_,
+			y,
+			w,
+			T,
+			O,
+			Xr(".", o),
+			Xr("]", o, qr())
+		] },
+		array_table_header: { rules: [Xr("[[", He, Kr("array_table_header_key"))] },
+		array_table_header_key: { rules: [
+			_,
+			y,
+			w,
+			T,
+			O,
+			Xr(".", o),
+			Xr("]]", He, qr())
+		] },
+		value: { rules: [
+			Zr(["\n", "\r"], Kr("root")),
+			...B("value", !0).filter((e) => e !== v),
+			ei(Kr("root"))
+		] },
+		value_array: { rules: [
+			...B("value_array", !0),
+			Xr(",", o),
+			Xr("]", o, qr())
+		] },
+		value_inline_table: { rules: [
+			_,
+			E,
+			D,
+			w,
+			T,
+			O,
+			Xr("=", a, Kr("value_inline_table_after_val")),
+			Xr(",", o),
+			Xr(".", o),
+			Xr("}", o, qr())
+		] },
+		value_inline_table_after_val: { rules: [
+			...B("value_inline_table_after_val", !1),
+			Zr(",", Kr("value_inline_table")),
+			Zr("}", Kr("value_inline_table"))
+		] },
+		basic_string_body: { rules: [
+			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 })
+		] },
+		ml_basic_string_body: { rules: [
+			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 })
+		] },
+		basic_key_body: { rules: [
+			Xr("\\u", Fe, Gr("esc_u4_d1")),
+			Xr("\\U", Fe, Gr("esc_u8_d1")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("\"", v$1, qr()),
+			ei({ token: v$1 })
+		] },
+		ml_basic_key_body: { rules: [
+			Xr("\\u", Fe, Gr("esc_u4_d1")),
+			Xr("\\U", Fe, Gr("esc_u8_d1")),
+			Xr("\\", Fe, Gr("esc_simple")),
+			Xr("\"\"\"", v$1, qr()),
+			ei({ token: v$1 })
+		] },
+		esc_simple: { rules: [ei({
+			token: Fe,
+			exit: !0
+		})] },
+		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())] },
+		...V,
+		...H
+	}
+});
+var W = _$1(U);
+var G = [];
+var K = qn(W, G);
+function q(e) {
+	let t = K(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { W as grammar, q as language, U as raw_grammar, G as reclassifiers, K as tokenize };

package/dist/dist-CtONMLh4.mjs

@@ -0,0 +1,283 @@
+import { C as Sr, 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 { $ as me, A as _e, B as ee, D as Y, E as W, H as fe, I as ce, K as ie, M as ae, O as Z, R as de, T as U, U as ge$1, Z as le, a as De, at as q, b as Q, c as G, dt as te, f as J, ht as ve, it as pe, l as H, lt as se, mt as v$1, p as K, pt as ue, rt as oe, st as re, t as $, tt as ne, v as Oe, w as T$1, x as R, yt as ye } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+//#region node_modules/.pnpm/@twinkleplop+markdown@0.1.4/node_modules/@twinkleplop/markdown/dist/index.js
+var g = Xr(/* @__PURE__ */ "\\! \\\" \\# \\$ \\% \\& \\' \\( \\) \\* \\+ \\, \\- \\. \\/ \\: \\; \\< \\= \\> \\? \\@ \\[ \\\\ \\] \\^ \\_ \\` \\{ \\| \\} \\~".split(" "), ve);
+var _ = Xr("\\\n", ye, Kr("block_start"));
+var v = Zr("\\\n", qr());
+var y = [
+	Xr("![", ce, Gr("link_text")),
+	Xr("[", ce, Gr("link_text")),
+	Xr("<", ee, Gr("autolink_body")),
+	Xr("&", T$1, Gr("entity_body")),
+	Xr("`", ie, Gr("code_body"))
+];
+var b = [
+	Xr("**", ne, Gr("bold_star_body")),
+	Xr("__", ne, Gr("bold_under_body")),
+	Xr("~~", ue, Gr("strike_body")),
+	Xr("*", oe, Gr("italic_star_body")),
+	Xr("_", oe, Gr("italic_under_body"))
+];
+var x = [_, g];
+var S = [v, g];
+var C = g$1({
+	name: "markdown",
+	states: {
+		main: { rules: [Xr("---\n", pe, Kr("front_matter_body")), ei(Kr("block_start"))] },
+		front_matter_body: { rules: [
+			Xr(["\n---\n", "\n...\n"], pe, Kr("block_start")),
+			Xr(["\n---", "\n..."], pe, Kr("block_start")),
+			ei({ token: Oe })
+		] },
+		block_start: { rules: [
+			Zr(["\n", "\r"]),
+			Xr(["    ", "	"], G, Gr("indented_code")),
+			Xr([
+				"``````",
+				"`````",
+				"````",
+				"```"
+			], fe, Kr("fence_info_btick")),
+			Xr([
+				"~~~~~~",
+				"~~~~~",
+				"~~~~",
+				"~~~"
+			], fe, Kr("fence_info_tilde")),
+			Xr([
+				"######",
+				"#####",
+				"####",
+				"###",
+				"##",
+				"#"
+			], me, Kr("heading_space")),
+			Xr([
+				"---",
+				"***",
+				"___"
+			], "hr", Kr("thematic_break_tail")),
+			Xr(">", de),
+			Xr([
+				"- ",
+				"* ",
+				"+ "
+			], ge$1, Kr("list_body_probe")),
+			Zr([" ", "	"]),
+			ei(Kr("inline_content"))
+		] },
+		heading_space: { rules: [
+			Zr("\n", Kr("block_start")),
+			Zr([" ", "	"], Kr("heading_body")),
+			ei(Kr("inline_content"))
+		] },
+		heading_body: { rules: [
+			Zr("\n", Kr("block_start")),
+			...x,
+			...y,
+			...b,
+			ei({ token: R })
+		] },
+		inline_content: { rules: [
+			Zr("\n", Kr("block_start")),
+			...x,
+			...y,
+			...b,
+			ei({})
+		] },
+		bold_star_body: { rules: [
+			Xr("**", te, qr()),
+			Zr("\n", qr()),
+			...S,
+			...y,
+			Xr("__", ne, Gr("bold_under_body")),
+			Xr("~~", ue, Gr("strike_body")),
+			Xr("*", oe, Gr("italic_star_body")),
+			Xr("_", oe, Gr("italic_under_body")),
+			ei({ token: U })
+		] },
+		bold_under_body: { rules: [
+			Xr("__", te, qr()),
+			Zr("\n", qr()),
+			...S,
+			...y,
+			Xr("**", ne, Gr("bold_star_body")),
+			Xr("~~", ue, Gr("strike_body")),
+			Xr("*", oe, Gr("italic_star_body")),
+			Xr("_", oe, Gr("italic_under_body")),
+			ei({ token: U })
+		] },
+		italic_star_body: { rules: [
+			Xr("*", ae, qr()),
+			Zr("\n", qr()),
+			...S,
+			...y,
+			Xr("**", ne, Gr("bold_star_body")),
+			Xr("__", ne, Gr("bold_under_body")),
+			Xr("~~", ue, Gr("strike_body")),
+			Xr("_", oe, Gr("italic_under_body")),
+			ei({ token: q })
+		] },
+		italic_under_body: { rules: [
+			Xr("_", ae, qr()),
+			Zr("\n", qr()),
+			...S,
+			...y,
+			Xr("**", ne, Gr("bold_star_body")),
+			Xr("__", ne, Gr("bold_under_body")),
+			Xr("~~", ue, Gr("strike_body")),
+			Xr("*", oe, Gr("italic_star_body")),
+			ei({ token: q })
+		] },
+		strike_body: { rules: [
+			Xr("~~", le, qr()),
+			Zr("\n", qr()),
+			...S,
+			...y,
+			Xr("**", ne, Gr("bold_star_body")),
+			Xr("__", ne, Gr("bold_under_body")),
+			Xr("*", oe, Gr("italic_star_body")),
+			Xr("_", oe, Gr("italic_under_body")),
+			ei({ token: Y })
+		] },
+		code_body: { rules: [
+			Xr("`", re, qr()),
+			Zr("\n", qr()),
+			ei({ token: W })
+		] },
+		link_text: { rules: [
+			Xr("]", se, Kr("link_after_close")),
+			Zr("\n", qr()),
+			...S,
+			Xr("<", ee, Gr("autolink_body")),
+			Xr("&", T$1, Gr("entity_body")),
+			Xr("`", ie, Gr("code_body")),
+			...b,
+			ei({ token: J })
+		] },
+		link_after_close: { rules: [
+			Xr("(", Z, Kr("link_destination")),
+			Xr("[", Z, Kr("link_reference_label")),
+			ei(qr())
+		] },
+		link_destination: { rules: [
+			Xr(")", Z, qr()),
+			Zr("\n", qr()),
+			$r("\"", "\"", Q, {
+				escape: "\\",
+				multiline: !1
+			}),
+			$r("'", "'", Q, {
+				escape: "\\",
+				multiline: !1
+			}),
+			ei({ token: "url" })
+		] },
+		link_reference_label: { rules: [
+			Xr("]", Z, qr()),
+			Zr("\n", qr()),
+			ei({ token: v$1 })
+		] },
+		autolink_body: { rules: [
+			Xr(">", $, qr()),
+			Zr("\n", qr()),
+			ei({ token: H })
+		] },
+		entity_body: { rules: [
+			Xr(";", T$1, qr()),
+			Xr([
+				Vr,
+				Hr,
+				"#",
+				"x"
+			], T$1),
+			ei(qr())
+		] },
+		list_body_probe: { rules: [Xr([
+			"[ ] ",
+			"[x] ",
+			"[X] "
+		], _e, Kr("inline_content")), ei(Kr("inline_content"))] },
+		indented_code: { rules: [Xr("\n", G, qr()), ei({ token: G })] },
+		thematic_break_tail: { rules: [
+			Xr("\n", "hr", Kr("block_start")),
+			Xr([
+				"-",
+				"*",
+				"_",
+				" ",
+				"	"
+			], "hr"),
+			ei(Kr("inline_content"))
+		] },
+		fence_info_btick: { rules: [Zr("\n", Kr("fence_body_btick")), ei({ token: K })] },
+		fence_body_btick: { rules: [Xr("\n", De, Kr("fence_maybe_close_btick")), ei({ token: De })] },
+		fence_maybe_close_btick: { rules: [Xr([
+			"``````",
+			"`````",
+			"````",
+			"```"
+		], fe, Kr("fence_close_tail")), ei(Kr("fence_body_btick"))] },
+		fence_info_tilde: { rules: [Zr("\n", Kr("fence_body_tilde")), ei({ token: K })] },
+		fence_body_tilde: { rules: [Xr("\n", De, Kr("fence_maybe_close_tilde")), ei({ token: De })] },
+		fence_maybe_close_tilde: { rules: [Xr([
+			"~~~~~~",
+			"~~~~~",
+			"~~~~",
+			"~~~"
+		], fe, Kr("fence_close_tail")), ei(Kr("fence_body_tilde"))] },
+		fence_close_tail: { rules: [Xr("\n", fe, Kr("block_start")), ei({ token: fe })] }
+	}
+});
+var w = [Vn(Sr({
+	auto_pop_on_newline: !0,
+	join_separator: " ",
+	dedup_against_base: !0,
+	styles: [
+		{
+			open_type: "bold_open",
+			close_type: "bold_close",
+			style_name: "bold"
+		},
+		{
+			open_type: "italic_open",
+			close_type: "italic_close",
+			style_name: "italic"
+		},
+		{
+			open_type: "strike_open",
+			close_type: "strike_close",
+			style_name: "strike"
+		},
+		{
+			open_type: "code_open",
+			close_type: "code_close",
+			style_name: "code"
+		},
+		{
+			open_type: "link_text_open",
+			close_type: "link_text_close",
+			style_name: "link_text"
+		},
+		{
+			open_type: "autolink_open",
+			close_type: "autolink_close",
+			style_name: "autolink"
+		}
+	]
+}), [
+	"bold",
+	"italic",
+	"strike",
+	"code",
+	"link_text",
+	"autolink"
+])];
+var T = _$1(C);
+var E = qn(T, w);
+function D(e) {
+	let t = E(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { T as grammar, D as language, C as raw_grammar, w as reclassifiers, E as tokenize };