comarkserv 0.1.0

package/dist/dist-V1rkISnf.mjs

@@ -0,0 +1,220 @@
+import { F as Zr, G as ge, M as Xr, R as br, S as Qr, V as ei, _ as Nn, et as qn, h as Lr, l as Hn, m as Kr, mt as g, pt as _, r as $r, s as Gr, tt as qr } from "./twinkleplop.production-DekYmX6O.mjs";
+import { C as Se, F as c, J as je, P as be, _t as xe, g as Ne, gt as w$1, j as a, nt as o, o as E$1, r as C$1, ut as t, y as Pe } from "./twinkleplop.tokens-CgBUTCSg.mjs";
+import { n as I } from "./dist-DMftjyxU.mjs";
+import { o as $ } from "./dist-BQzCbTko.mjs";
+//#region node_modules/.pnpm/@twinkleplop+svelte@0.1.4/node_modules/@twinkleplop/svelte/dist/index.js
+var y = Lr([
+	["a", "z"],
+	["A", "Z"],
+	["0", "9"],
+	["-", "-"],
+	["_", "_"],
+	[":", ":"]
+]);
+var b = Lr([
+	["a", "z"],
+	["A", "Z"],
+	["0", "9"],
+	["-", "-"],
+	["_", "_"]
+]);
+var x = [
+	"if",
+	"each",
+	"await",
+	"key",
+	"snippet",
+	"else if",
+	"else",
+	"then",
+	"catch"
+];
+var S = [
+	"html",
+	"const",
+	"debug",
+	"render"
+];
+var C = [
+	Zr([
+		" ",
+		"	",
+		"\n",
+		"\r"
+	]),
+	Xr("=", a),
+	Xr("{", be, Gr("expression_body")),
+	Xr("\"", c, Gr("attr_string_double")),
+	Xr("'", c, Gr("attr_string_single")),
+	Xr([
+		"bind:",
+		"on:",
+		"use:",
+		"transition:",
+		"in:",
+		"out:",
+		"animate:",
+		"class:",
+		"style:",
+		"let:"
+	], Se),
+	Xr("|", o),
+	Xr(b, C$1)
+];
+var w = [
+	$r("\"", "\"", Pe, {
+		escape: "\\",
+		multiline: !0
+	}),
+	$r("'", "'", Pe, {
+		escape: "\\",
+		multiline: !0
+	}),
+	$r("/*", "*/", Pe, { multiline: !0 }),
+	$r("//", "\n", Pe),
+	Xr("{", Pe, Gr("expression_brace")),
+	ei({ token: Pe })
+];
+var T = g({
+	name: "svelte",
+	states: {
+		content: { rules: [
+			$r("<!--", "-->", t),
+			Xr(["<!DOCTYPE", "<!doctype"], w$1, Gr("doctype")),
+			Xr("</", o, Gr("close_tag")),
+			Xr("<", o, Gr("tag_start")),
+			Xr("{", be, Gr("brace_start")),
+			ei({})
+		] },
+		brace_start: { rules: [
+			Xr([
+				"#",
+				"/",
+				":"
+			], o, Kr("block_keyword")),
+			Xr("@", o, Kr("at_directive_keyword")),
+			ei(Kr("expression_body"))
+		] },
+		block_keyword: { rules: [Xr(x, xe, Kr("expression_body")), ei(Kr("expression_body"))] },
+		at_directive_keyword: { rules: [Xr(S, xe, Kr("expression_body")), ei(Kr("expression_body"))] },
+		tag_start: { rules: [
+			Qr(["script"], Kr("script_attrs"), E$1),
+			Qr(["style"], Kr("style_attrs"), E$1),
+			Xr("svelte", "keyword", {
+				boundary: !0,
+				...Kr("tag_svelte_ns")
+			}),
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("tag_attrs")),
+			Xr(y, E$1, Kr("tag_open"))
+		] },
+		tag_svelte_ns: { rules: [Xr(":", o, Kr("tag_open")), ei(Kr("tag_open"))] },
+		tag_open: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			], Kr("tag_attrs")),
+			Xr(y, E$1)
+		] },
+		tag_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, qr()),
+			...C
+		] },
+		close_tag: { rules: [
+			Xr(">", o, qr()),
+			Zr([
+				" ",
+				"	",
+				"\n",
+				"\r"
+			]),
+			Xr(y, E$1)
+		] },
+		doctype: { rules: [Xr(">", o, qr()), ei({ token: w$1 })] },
+		script_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, Kr("script_content")),
+			...C
+		] },
+		script_content: { rules: [Zr("</", Gr("script_close_probe")), ei({ token: je })] },
+		script_close_probe: {
+			mode: "probe",
+			fallback: "script_close_fail",
+			rules: [Zr("script>", Kr("script_close_emit"))]
+		},
+		script_close_fail: { rules: [Xr("<", je, qr())] },
+		script_close_emit: { rules: [Xr("</", o, Kr("script_close_name"))] },
+		script_close_name: { rules: [Xr("script", E$1, Kr("script_close_gt"))] },
+		script_close_gt: { rules: [Xr(">", o, qr())] },
+		style_attrs: { rules: [
+			Xr("/>", o, qr()),
+			Xr(">", o, Kr("style_content")),
+			...C
+		] },
+		style_content: { rules: [Zr("</", Gr("style_close_probe")), ei({ token: Ne })] },
+		style_close_probe: {
+			mode: "probe",
+			fallback: "style_close_fail",
+			rules: [Zr("style>", Kr("style_close_emit"))]
+		},
+		style_close_fail: { rules: [Xr("<", Ne, qr())] },
+		style_close_emit: { rules: [Xr("</", o, Kr("style_close_name"))] },
+		style_close_name: { rules: [Xr("style", E$1, Kr("style_close_gt"))] },
+		style_close_gt: { rules: [Xr(">", o, qr())] },
+		attr_string_double: { rules: [
+			Xr("\"", c, qr()),
+			Xr("{", be, Gr("expression_body")),
+			ei({ token: c })
+		] },
+		attr_string_single: { rules: [
+			Xr("'", c, qr()),
+			Xr("{", be, Gr("expression_body")),
+			ei({ token: c })
+		] },
+		expression_body: { rules: [Xr("}", be, qr()), ...w] },
+		expression_brace: { rules: [Xr("}", Pe, qr()), ...w] }
+	}
+});
+var E;
+var D;
+var O = (e) => (E ??= $())(e);
+var k = [Hn(br({
+	open_type: "expression",
+	open_text: "{",
+	close_type: "expression",
+	close_text: "}",
+	post_open_required: {
+		type: "punctuation",
+		text_in: [
+			"#",
+			":",
+			"/",
+			"@"
+		]
+	},
+	retag_open_to: "punctuation",
+	retag_close_to: "punctuation"
+}), "type_claim"), Hn(Nn({
+	raw_script: O,
+	raw_style: (e) => (D ??= I())(e),
+	raw_svelte_expression: O
+}), "embed")];
+var A = _(T);
+var j = qn(A, k);
+function M(e) {
+	let t = j(e);
+	return (e, n) => ge(e, t(e), n);
+}
+//#endregion
+export { A as grammar, M as language, T as raw_grammar, k as reclassifiers, j as tokenize };

package/dist/dist-ZoN94PJ0.mjs

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { constants } from "node:os";
+import { createInterface } from "node:readline/promises";
+//#region node_modules/.pnpm/untun@0.2.2/node_modules/untun/dist/_chunks/log.mjs
+function log(message, type) {
+	const color = type && colors[type];
+	console.log(color ? `${color}${message}${colors.reset}` : message);
+}
+async function prompt(message) {
+	if (!process.stdin.isTTY) return true;
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await rl.question(`${colors.info}?${colors.reset} ${message} ${colors.dim}(Y/n)${colors.reset} `);
+		return !/^n(o)?$/i.test(answer.trim());
+	} finally {
+		rl.close();
+	}
+}
+const colors = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	info: "\x1B[36m",
+	success: "\x1B[32m",
+	error: "\x1B[31m",
+	warn: "\x1B[33m"
+};
+//#endregion
+//#region node_modules/.pnpm/untun@0.2.2/node_modules/untun/dist/index.mjs
+async function startTunnel(opts) {
+	const { installCloudflared, startCloudflaredTunnel, cloudflaredBinPath, cloudflaredNotice } = await import("./cloudflared-6f_lzz4F.mjs");
+	const url = opts.url || `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3e3}`;
+	log(`Starting cloudflared tunnel to ${url}`, "info");
+	if (!existsSync(cloudflaredBinPath)) {
+		log(cloudflaredNotice);
+		if (!(opts.acceptCloudflareNotice || process.env.UNTUN_ACCEPT_CLOUDFLARE_NOTICE || await prompt(`Do you agree with the above terms and wish to install the binary from GitHub?`))) {
+			log("Skipping tunnel setup.", "error");
+			return;
+		}
+		await installCloudflared();
+	}
+	const args = [["--url", url], opts.verifyTLS ? void 0 : ["--no-tls-verify", null]].filter(Boolean);
+	const tunnel = startCloudflaredTunnel(Object.fromEntries(args), opts.extraArgs);
+	let closed = false;
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	const handlers = /* @__PURE__ */ new Map();
+	const cleanup = async () => {
+		if (closed) return;
+		closed = true;
+		for (const [sig, handler] of handlers) process.off(sig, handler);
+		handlers.clear();
+		await tunnel.stop();
+	};
+	for (const signal of signals) {
+		const handler = () => {
+			cleanup().finally(() => {
+				const signo = constants.signals[signal] ?? 0;
+				process.exit(128 + signo);
+			});
+		};
+		handlers.set(signal, handler);
+		process.once(signal, handler);
+	}
+	return {
+		getURL: () => tunnel.url,
+		close: cleanup
+	};
+}
+//#endregion
+export { startTunnel };