@cowliss/cli 0.1.0

package/dist/guest/prelude.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/guest/prelude.js

@@ -0,0 +1,91 @@
+//#region src/guest/prelude.ts
+const STDERR = 2;
+function port() {
+	return {
+		onmessage: null,
+		postMessage() {},
+		close() {}
+	};
+}
+/**
+* The scheme, authority, path, query, and fragment split of RFC 3986
+* appendix B, tightened to require a scheme: a string without one is what
+* the constructor rejects.
+*/
+const URL_PARTS = /^([A-Za-z][A-Za-z0-9+.-]*):(?:\/\/([^/?#]*))?([^?#]*)(\?[^#]*)?(#.*)?$/;
+/** Schemes whose `origin` is the scheme and authority rather than "null". */
+const SPECIAL = [
+	"http:",
+	"https:",
+	"ws:",
+	"wss:",
+	"ftp:"
+];
+/**
+* ponytail: a regex split, not a WHATWG parser. No IDNA, no percent
+* normalisation, no `searchParams`, and no resolution of a relative input
+* against a base. Swap in `whatwg-url` if a tenant ever hits a false
+* negative; it is not here today because it would land in the bundle of
+* every template and every journey.
+*/
+var GuestURL = class {
+	href;
+	protocol;
+	hostname;
+	port;
+	pathname;
+	search;
+	hash;
+	constructor(input, base) {
+		if (base !== void 0) throw new TypeError("Invalid URL: this sandbox resolves no relative URLs, so `new URL(input, base)` needs an absolute `input`");
+		const raw = String(input).trim();
+		const parts = /\s/.test(raw) ? null : URL_PARTS.exec(raw);
+		if (parts === null) throw new TypeError("Invalid URL");
+		const authority = parts[2];
+		const path = parts[3] ?? "";
+		this.protocol = `${(parts[1] ?? "").toLowerCase()}:`;
+		const hostPort = (authority ?? "").split("@").pop() ?? "";
+		const colon = hostPort.lastIndexOf(":");
+		const split = colon > hostPort.lastIndexOf("]") ? colon : -1;
+		this.hostname = (split === -1 ? hostPort : hostPort.slice(0, split)).toLowerCase();
+		this.port = split === -1 ? "" : hostPort.slice(split + 1);
+		this.pathname = path === "" && authority !== void 0 ? "/" : path;
+		this.search = parts[4] ?? "";
+		this.hash = parts[5] ?? "";
+		this.href = `${this.protocol}${authority === void 0 ? "" : `//${this.host}`}${this.pathname}${this.search}${this.hash}`;
+	}
+	get host() {
+		return this.port === "" ? this.hostname : `${this.hostname}:${this.port}`;
+	}
+	get origin() {
+		return SPECIAL.includes(this.protocol) ? `${this.protocol}//${this.host}` : "null";
+	}
+	toString() {
+		return this.href;
+	}
+	toJSON() {
+		return this.href;
+	}
+};
+if (typeof Javy !== "undefined") {
+	const globals = globalThis;
+	globals.MessageChannel ??= function MessageChannel() {
+		this.port1 = port();
+		this.port2 = port();
+	};
+	globals.URL ??= GuestURL;
+	const encoder = new TextEncoder();
+	const write = (parts) => {
+		Javy.IO.writeSync(STDERR, encoder.encode(`${parts.map((part) => String(part)).join(" ")}\n`));
+	};
+	for (const level of [
+		"log",
+		"info",
+		"warn",
+		"error",
+		"debug",
+		"trace"
+	]) console[level] = (...parts) => write(parts);
+}
+
+//#endregion

package/dist/guest/wasi.d.ts

@@ -0,0 +1,6 @@
+import { GuestModule } from "./driver.js";
+//#region src/guest/wasi.d.ts
+/** Drives one invocation of the module this bundle was built for. */
+declare function main(module: GuestModule): void;
+//#endregion
+export { main };

package/dist/guest/wasi.js

@@ -0,0 +1,43 @@
+import { t as runGuest } from "./driver-BOe7jBFw.js";
+
+//#region src/guest/wasi.ts
+const STDIN = 0;
+const STDOUT = 1;
+const STDERR = 2;
+const CHUNK_BYTES = 65536;
+function readStdin() {
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const chunk = new Uint8Array(CHUNK_BYTES);
+		const read = Javy.IO.readSync(STDIN, chunk);
+		if (read <= 0) break;
+		chunks.push(chunk.subarray(0, read));
+		total += read;
+	}
+	const input = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		input.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return new TextDecoder().decode(input);
+}
+function write(fd, text) {
+	Javy.IO.writeSync(fd, new TextEncoder().encode(text));
+}
+/** Drives one invocation of the module this bundle was built for. */
+function main(module) {
+	const fail = (error) => {
+		write(STDERR, error instanceof Error ? error.message : String(error));
+		throw error;
+	};
+	try {
+		runGuest(module, JSON.parse(readStdin())).then((output) => write(STDOUT, JSON.stringify(output))).catch(fail);
+	} catch (error) {
+		fail(error);
+	}
+}
+
+//#endregion
+export { main };