@gera2ld/common-node 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,415 +1,373 @@
-import { spawn as D } from "node:child_process";
-import { stat as A, mkdir as v, readFile as q, writeFile as U, readdir as S, rm as P, access as L, rename as $ } from "node:fs/promises";
-import { resolve as C, extname as z, dirname as g, normalize as K, join as d } from "node:path";
-import R from "node:process";
-import { Readable as E } from "node:stream";
-import { buffer as k } from "node:stream/consumers";
-import { isatty as O } from "node:tty";
-function W(r) {
-  return new TextEncoder().encode(r);
+import { spawn as e } from "node:child_process";
+import { access as t, mkdir as n, readFile as r, readdir as i, rename as a, rm as o, stat as s, writeFile as c } from "node:fs/promises";
+import { dirname as l, extname as u, join as d, normalize as f, resolve as p } from "node:path";
+import m from "node:process";
+import { Readable as h } from "node:stream";
+import { buffer as g } from "node:stream/consumers";
+import { isatty as _ } from "node:tty";
+//#region ../../node_modules/.pnpm/@gera2ld+common@file+packages+common/node_modules/@gera2ld/common/dist/index.js
+function v(e) {
+	return new TextEncoder().encode(e);
 }
-function b() {
-  const r = {
-    status: "pending"
-  };
-  return r.promise = new Promise((t, e) => {
-    r.resolve = t, r.reject = e;
-  }), r.promise.then(
-    () => {
-      r.status = "resolved";
-    },
-    () => {
-      r.status = "rejected";
-    }
-  ), r;
+function y() {
+	let e = { status: "pending" };
+	return e.promise = new Promise((t, n) => {
+		e.resolve = t, e.reject = n;
+	}), e.promise.then(() => {
+		e.status = "resolved";
+	}, () => {
+		e.status = "rejected";
+	}), e;
 }
-const x = new Uint8Array([13, 10]);
-class J {
-  buffer = new Uint8Array(0);
-  requests = [];
-  isClosed = !1;
-  read(t = 8192) {
-    const e = b();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        const s = Math.min(t, this.buffer.length), a = this.buffer.subarray(0, s);
-        return this.buffer = this.buffer.subarray(s), e.resolve(a), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  readExact(t) {
-    const e = b();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        if (t > this.buffer.length) return !1;
-        const s = this.buffer.subarray(0, t);
-        return this.buffer = this.buffer.subarray(t), e.resolve(s), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  readUntil(t = x) {
-    typeof t == "string" && (t = W(t));
-    const e = b();
-    return this.requests.push({
-      deferred: e,
-      handle: () => {
-        const s = G(this.buffer, t);
-        if (s < 0) return !1;
-        const a = s + t.length, n = this.buffer.subarray(0, a);
-        return this.buffer = this.buffer.subarray(a), e.resolve(n), !0;
-      }
-    }), this.processBuffer(), e.promise;
-  }
-  feed(t) {
-    if (this.isClosed) throw new Error("Buffer is closed");
-    this.buffer = V(this.buffer, t), this.processBuffer();
-  }
-  close() {
-    this.isClosed = !0, this.processBuffer();
-  }
-  processBuffer() {
-    for (; this.requests.length; ) {
-      const t = this.requests[0];
-      if (!t.handle())
-        if (this.isClosed)
-          t.deferred.reject(new Error("Buffer is closed"));
-        else break;
-      this.requests.shift();
-    }
-  }
-}
-function V(r, t) {
-  const e = new Uint8Array(r.length + t.length);
-  return e.set(r, 0), e.set(t, r.length), e;
-}
-function G(r, t) {
-  if (!t.length) return 0;
-  for (let e = 0; e <= r.length - t.length; e += 1) {
-    let s;
-    for (s = 0; s < t.length && r[e + s] === t[s]; s += 1)
-      ;
-    if (s === t.length) return e;
-  }
-  return -1;
-}
-const Q = {
-  cgiDir: R.env.CGI_DIR || "cgi",
-  runnerMap: {
-    ".js": ["node"],
-    ".sh": ["bash"]
-  },
-  env: {},
-  timeout: 1e4,
-  // Do not allow directories or files starting with `.` or `_`
-  disallowedPattern: /\/[._]/
+var b = new Uint8Array([13, 10]), x = class {
+	buffer = new Uint8Array();
+	requests = [];
+	isClosed = !1;
+	read(e = 8192) {
+		let t = y();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				let n = Math.min(e, this.buffer.length), r = this.buffer.subarray(0, n);
+				return this.buffer = this.buffer.subarray(n), t.resolve(r), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	readExact(e) {
+		let t = y();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				if (e > this.buffer.length) return !1;
+				let n = this.buffer.subarray(0, e);
+				return this.buffer = this.buffer.subarray(e), t.resolve(n), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	readUntil(e = b) {
+		typeof e == "string" && (e = v(e));
+		let t = y();
+		return this.requests.push({
+			deferred: t,
+			handle: () => {
+				let n = C(this.buffer, e);
+				if (n < 0) return !1;
+				let r = n + e.length, i = this.buffer.subarray(0, r);
+				return this.buffer = this.buffer.subarray(r), t.resolve(i), !0;
+			}
+		}), this.processBuffer(), t.promise;
+	}
+	feed(e) {
+		if (this.isClosed) throw Error("Buffer is closed");
+		this.buffer = S(this.buffer, e), this.processBuffer();
+	}
+	close() {
+		this.isClosed = !0, this.processBuffer();
+	}
+	processBuffer() {
+		for (; this.requests.length;) {
+			let e = this.requests[0];
+			if (!e.handle()) if (this.isClosed) e.deferred.reject(/* @__PURE__ */ Error("Buffer is closed"));
+			else break;
+			this.requests.shift();
+		}
+	}
 };
-function it(r, t) {
-  return async function(s) {
-    const a = new URL(s.url), n = "." + C(a.pathname), i = {
-      ...Q,
-      ...r
-    };
-    if (i.disallowedPattern.test(n))
-      return new Response(null, { status: 403 });
-    const o = C(i.cgiDir, n);
-    try {
-      await A(o);
-    } catch {
-      return new Response(null, { status: 404 });
-    }
-    const u = i.runnerMap[z(o)];
-    try {
-      if (!u) throw new Error("Unsupported command");
-      t?.log?.(`Run hook: ${n}`);
-      const [f, ...w] = [...u, o], c = D(f, w, {
-        cwd: g(o),
-        env: {
-          ...R.env,
-          ...i.env,
-          HTTP_METHOD: s.method,
-          HTTP_URL: s.url,
-          HTTP_HEADERS: [...s.headers.entries()].map((l) => `${l[0]}: ${l[1]}`).join(`
-`)
-        },
-        stdio: ["pipe", "pipe", "inherit"],
-        timeout: i.timeout
-      });
-      s.body ? E.fromWeb(s.body).pipe(c.stdin) : c.stdin.end();
-      let y = !1;
-      const h = new J(), N = h.readUntil(`
-
-`).finally(() => {
-        y = !0;
-      });
-      for await (const l of c.stdout)
-        if (h.feed(l), y) break;
-      y || h.close();
-      const B = await N, M = JSON.parse(new TextDecoder().decode(B)), { status: m, ...j } = M;
-      let p = m ? +m : 200;
-      if (isNaN(p) || p < 100 || p > 999)
-        throw new Error(`Invalid status code: ${m}`);
-      c.exitCode && (console.error("Script exit code:", c.exitCode), p = 500);
-      const F = E.toWeb(
-        E.from(
-          (async function* () {
-            for (; ; ) {
-              const l = await h.read();
-              if (!l.length) break;
-              yield l;
-            }
-            for await (const l of c.stdout)
-              yield l;
-          })()
-        )
-      );
-      return new Response(F, {
-        status: p,
-        headers: j
-      });
-    } catch (f) {
-      return t?.log?.(`Error: ${f}`), new Response("Internal server error", {
-        status: 500
-      });
-    }
-  };
-}
-class X extends Error {
-  constructor(t) {
-    super(`Command exit code: ${t.code}`), this.output = t;
-  }
-}
-async function ot(r, t, e) {
-  const s = e?.ensureSuccess ?? !0, a = [
-    ...t?.stdio || ["ignore", "inherit", "inherit"]
-  ];
-  e?.stdin && (a[0] = "pipe"), e?.buffer && (e.buffer !== "stderr" && (a[1] = "pipe"), e.buffer !== "stdout" && (a[2] = "pipe"));
-  const n = D(r[0], r.slice(1), {
-    ...t,
-    stdio: a
-  });
-  if (e?.stdin && n.stdin) {
-    const c = typeof e.stdin == "string" ? new TextEncoder().encode(e.stdin) : e.stdin instanceof ArrayBuffer ? new Uint8Array(e.stdin) : e.stdin;
-    n.stdin.write(c), n.stdin.end();
-  }
-  const i = n.stdout && k(n.stdout), o = n.stderr && k(n.stderr), u = await new Promise(
-    (c) => n.on("exit", (y, h) => {
-      c({ code: y, signal: h });
-    })
-  ), f = !u.code && !u.signal, w = {
-    success: f,
-    code: u.code,
-    signal: u.signal,
-    async stdout() {
-      if (!i) throw new Error("stdout is not available");
-      return i;
-    },
-    async stderr() {
-      if (!o) throw new Error("stderr is not available");
-      return o;
-    }
-  };
-  if (s && !f)
-    throw new X(w);
-  return w;
+function S(e, t) {
+	let n = new Uint8Array(e.length + t.length);
+	return n.set(e, 0), n.set(t, e.length), n;
 }
-async function ct() {
-  return O(process.stdin.fd) ? void 0 : await k(process.stdin);
+function C(e, t) {
+	if (!t.length) return 0;
+	for (let n = 0; n <= e.length - t.length; n += 1) {
+		let r;
+		for (r = 0; r < t.length && e[n + r] === t[r]; r += 1);
+		if (r === t.length) return n;
+	}
+	return -1;
 }
-function _(r) {
-  const t = R.env[r];
-  if (!t)
-    throw new Error(`Missing environment variable: ${r}`);
-  return t;
-}
-function ut(r) {
-  const t = {}, e = [];
-  for (const s of r)
-    try {
-      const a = _(s);
-      t[s] = a;
-    } catch {
-      e.push(s);
-    }
-  if (e.length)
-    throw new Error(`Missing environment variables: ${e.join(", ")}`);
-  return t;
+//#endregion
+//#region src/cgi.ts
+var w = {
+	cgiDir: m.env.CGI_DIR || "cgi",
+	runnerMap: {
+		".js": ["node"],
+		".sh": ["bash"]
+	},
+	env: {},
+	timeout: 1e4,
+	disallowedPattern: /\/[._]/
+};
+function T(t, n) {
+	return async function(r) {
+		let i = "." + p(new URL(r.url).pathname), a = {
+			...w,
+			...t
+		};
+		if (a.disallowedPattern.test(i)) return new Response(null, { status: 403 });
+		let o = p(a.cgiDir, i);
+		try {
+			await s(o);
+		} catch {
+			return new Response(null, { status: 404 });
+		}
+		let c = a.runnerMap[u(o)];
+		try {
+			if (!c) throw Error("Unsupported command");
+			n?.log?.(`Run hook: ${i}`);
+			let [t, ...s] = [...c, o], u = e(t, s, {
+				cwd: l(o),
+				env: {
+					...m.env,
+					...a.env,
+					HTTP_METHOD: r.method,
+					HTTP_URL: r.url,
+					HTTP_HEADERS: [...r.headers.entries()].map((e) => `${e[0]}: ${e[1]}`).join("\n")
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					"inherit"
+				],
+				timeout: a.timeout
+			});
+			r.body ? h.fromWeb(r.body).pipe(u.stdin) : u.stdin.end();
+			let d = !1, f = new x(), p = f.readUntil("\n\n").finally(() => {
+				d = !0;
+			});
+			for await (let e of u.stdout) if (f.feed(e), d) break;
+			d || f.close();
+			let g = await p, { status: _, ...v } = JSON.parse(new TextDecoder().decode(g)), y = Number(_ ? +_ : 200);
+			if (isNaN(y) || y < 100 || y > 999) throw Error(`Invalid status code: ${_}`);
+			u.exitCode && (console.error("Script exit code:", u.exitCode), y = 500);
+			let b = h.toWeb(h.from((async function* () {
+				for (;;) {
+					let e = await f.read();
+					if (!e.length) break;
+					yield e;
+				}
+				for await (let e of u.stdout) yield e;
+			})()));
+			return new Response(b, {
+				status: y,
+				headers: v
+			});
+		} catch (e) {
+			return n?.log?.(`Error: ${e}`), new Response("Internal server error", { status: 500 });
+		}
+	};
 }
-class T {
-  constructor(t, e) {
-    this.root = t, this.options = { ...T.defaultOptions, ...e };
-  }
-  static defaultOptions = {
-    pathToKey: (t) => t.endsWith(".txt") ? t.slice(0, -4) : void 0,
-    keyToPath: (t) => t + ".txt"
-  };
-  static async open(t = ".", e) {
-    return await v(t, { recursive: !0 }), new T(t, e);
-  }
-  options;
-  normalizeKey(t) {
-    const e = K("./" + this.options.keyToPath(t)).replaceAll(
-      "\\",
-      "/"
-    );
-    if (e.startsWith(".")) throw new Error("Invalid key");
-    return e;
-  }
-  async get(t) {
-    const e = d(this.root, this.normalizeKey(t));
-    try {
-      return await q(e, "utf8");
-    } catch {
-    }
-  }
-  async set(t, e) {
-    const s = d(this.root, this.normalizeKey(t));
-    await v(g(s), { recursive: !0 }), await U(s, e);
-  }
-  async *loadDir(t) {
-    const e = d(this.root, t);
-    for (const s of await S(e)) {
-      const a = d(e, s), n = await A(a), i = d(t, s);
-      if (n.isDirectory())
-        yield* this.loadDir(i);
-      else {
-        const o = this.options.pathToKey(i);
-        o && (yield o);
-      }
-    }
-  }
-  async keys() {
-    const t = [];
-    for await (const e of this.loadDir(""))
-      t.push(e);
-    return t;
-  }
-  async removeEmptyDirs(t) {
-    const e = [this.root, ...t.split("/")];
-    for (e.pop(); e.length > 1; ) {
-      const s = d(...e);
-      if ((await S(s)).length) break;
-      await P(s);
-    }
-  }
-  async del(t) {
-    const e = this.normalizeKey(t), s = d(this.root, e);
-    await P(s), await this.removeEmptyDirs(e);
-  }
-  async rename(t, e) {
-    const s = this.normalizeKey(t), a = this.normalizeKey(e), n = d(this.root, s), i = d(this.root, a);
-    await L(n), await v(g(i), { recursive: !0 }), await $(n, i);
-  }
-  async all() {
-    const t = [];
-    for await (const e of this.loadDir(""))
-      t.push({
-        key: e,
-        value: await this.get(e) || ""
-      });
-    return t;
-  }
+//#endregion
+//#region src/cli.ts
+var E = class extends Error {
+	constructor(e) {
+		super(`Command exit code: ${e.code}`), this.output = e;
+	}
+};
+async function D(t, n, r) {
+	let i = r?.ensureSuccess ?? !0, a = [...n?.stdio || [
+		"ignore",
+		"inherit",
+		"inherit"
+	]];
+	r?.stdin && (a[0] = "pipe"), r?.buffer && (r.buffer !== "stderr" && (a[1] = "pipe"), r.buffer !== "stdout" && (a[2] = "pipe"));
+	let o = e(t[0], t.slice(1), {
+		...n,
+		stdio: a
+	});
+	if (r?.stdin && o.stdin) {
+		let e = typeof r.stdin == "string" ? new TextEncoder().encode(r.stdin) : r.stdin instanceof ArrayBuffer ? new Uint8Array(r.stdin) : r.stdin;
+		o.stdin.write(e), o.stdin.end();
+	}
+	let s = o.stdout && g(o.stdout), c = o.stderr && g(o.stderr), l = await new Promise((e) => o.on("exit", (t, n) => {
+		e({
+			code: t,
+			signal: n
+		});
+	})), u = !l.code && !l.signal, d = {
+		success: u,
+		code: l.code,
+		signal: l.signal,
+		async stdout() {
+			if (!s) throw Error("stdout is not available");
+			return s;
+		},
+		async stderr() {
+			if (!c) throw Error("stderr is not available");
+			return c;
+		}
+	};
+	if (i && !u) throw new E(d);
+	return d;
 }
-class I {
-  constructor(t, e = {}) {
-    this.path = t, this.data = e;
-  }
-  static async open(t = "kv.json") {
-    const e = new I(t);
-    return await e.load(), e;
-  }
-  async load() {
-    let t;
-    try {
-      t = JSON.parse(await q(this.path, "utf8"));
-    } catch {
-    }
-    t ||= {}, this.data = t;
-  }
-  async dump() {
-    await U(this.path, JSON.stringify(this.data));
-  }
-  async get(t) {
-    return this.data[t];
-  }
-  async set(t, e) {
-    this.data[t] = e, await this.dump();
-  }
-  async keys() {
-    return Object.keys(this.data);
-  }
-  async del(t) {
-    delete this.data[t], await this.dump();
-  }
-  async rename(t, e) {
-    this.data[e] = this.data[t], delete this.data[t], await this.dump();
-  }
-  async all() {
-    return Object.entries(this.data).map(([t, e]) => ({ key: t, value: e }));
-  }
+async function O() {
+	if (!_(process.stdin.fd)) return await g(process.stdin);
 }
-const Y = `
-CREATE TABLE IF NOT EXISTS kv (
-  key VARCHAR UNIQUE,
-  value VARCHAR
-);
-`;
-class H {
-  constructor(t) {
-    this.adapter = t, t.exec(Y);
-  }
-  static async open(t) {
-    return new H(t);
-  }
-  async get(t) {
-    return this.adapter.queryRow(
-      "SELECT value FROM kv WHERE key=?1",
-      t
-    )?.value;
-  }
-  async set(t, e) {
-    this.adapter.queryRow(
-      "INSERT INTO kv(key, value) VALUES(?1, ?2) ON CONFLICT(key) DO UPDATE SET value=?2",
-      t,
-      e
-    );
-  }
-  async keys() {
-    return this.adapter.queryRows("SELECT key FROM kv").map((e) => e.key);
-  }
-  async del(t) {
-    this.adapter.queryRow("DELETE FROM kv WHERE key=?", t);
-  }
-  async rename(t, e) {
-    this.adapter.queryRow("UPDATE kv SET key=?1 WHERE key=?2", e, t);
-  }
-  async all() {
-    return this.adapter.queryRows(
-      "SELECT key, value FROM kv"
-    );
-  }
+//#endregion
+//#region src/env.ts
+function k(e) {
+	let t = m.env[e];
+	if (!t) throw Error(`Missing environment variable: ${e}`);
+	return t;
 }
-function lt(r) {
-  return function(e) {
-    const { sql: s, params: a, type: n } = {
-      sql: e.sql,
-      params: e.params ?? [],
-      type: e.type ?? "values"
-    }, i = r(), u = i.prepare(s)[n === "values" ? "values" : "all"](...a);
-    return i.destroy(), u;
-  };
+function A(e) {
+	let t = {}, n = [];
+	for (let r of e) try {
+		t[r] = k(r);
+	} catch {
+		n.push(r);
+	}
+	if (n.length) throw Error(`Missing environment variables: ${n.join(", ")}`);
+	return t;
 }
-export {
-  X as CommandError,
-  T as KvFile,
-  I as KvJson,
-  H as KvSqlite,
-  it as createCGIHandler,
-  Q as defaultConfig,
-  _ as ensureEnv,
-  ut as ensureEnvs,
-  lt as getSqlHandler,
-  ct as readStdIn,
-  ot as runCommand
+//#endregion
+//#region src/kv/file.ts
+var j = class e {
+	static defaultOptions = {
+		pathToKey: (e) => e.endsWith(".txt") ? e.slice(0, -4) : void 0,
+		keyToPath: (e) => e + ".txt"
+	};
+	static async open(t = ".", r) {
+		return await n(t, { recursive: !0 }), new e(t, r);
+	}
+	options;
+	constructor(t, n) {
+		this.root = t, this.options = {
+			...e.defaultOptions,
+			...n
+		};
+	}
+	normalizeKey(e) {
+		let t = f("./" + this.options.keyToPath(e)).replaceAll("\\", "/");
+		if (t.startsWith(".")) throw Error("Invalid key");
+		return t;
+	}
+	async get(e) {
+		let t = d(this.root, this.normalizeKey(e));
+		try {
+			return await r(t, "utf8");
+		} catch {}
+	}
+	async set(e, t) {
+		let r = d(this.root, this.normalizeKey(e));
+		await n(l(r), { recursive: !0 }), await c(r, t);
+	}
+	async *loadDir(e) {
+		let t = d(this.root, e);
+		for (let n of await i(t)) {
+			let r = await s(d(t, n)), i = d(e, n);
+			if (r.isDirectory()) yield* this.loadDir(i);
+			else {
+				let e = this.options.pathToKey(i);
+				e && (yield e);
+			}
+		}
+	}
+	async keys() {
+		let e = [];
+		for await (let t of this.loadDir("")) e.push(t);
+		return e;
+	}
+	async removeEmptyDirs(e) {
+		let t = [this.root, ...e.split("/")];
+		for (t.pop(); t.length > 1;) {
+			let e = d(...t);
+			if ((await i(e)).length) break;
+			await o(e);
+		}
+	}
+	async del(e) {
+		let t = this.normalizeKey(e);
+		await o(d(this.root, t)), await this.removeEmptyDirs(t);
+	}
+	async rename(e, r) {
+		let i = this.normalizeKey(e), o = this.normalizeKey(r), s = d(this.root, i), c = d(this.root, o);
+		await t(s), await n(l(c), { recursive: !0 }), await a(s, c);
+	}
+	async all() {
+		let e = [];
+		for await (let t of this.loadDir("")) e.push({
+			key: t,
+			value: await this.get(t) || ""
+		});
+		return e;
+	}
+}, M = class e {
+	static async open(t = "kv.json") {
+		let n = new e(t);
+		return await n.load(), n;
+	}
+	constructor(e, t = {}) {
+		this.path = e, this.data = t;
+	}
+	async load() {
+		let e;
+		try {
+			e = JSON.parse(await r(this.path, "utf8"));
+		} catch {}
+		e ||= {}, this.data = e;
+	}
+	async dump() {
+		await c(this.path, JSON.stringify(this.data));
+	}
+	async get(e) {
+		return this.data[e];
+	}
+	async set(e, t) {
+		this.data[e] = t, await this.dump();
+	}
+	async keys() {
+		return Object.keys(this.data);
+	}
+	async del(e) {
+		delete this.data[e], await this.dump();
+	}
+	async rename(e, t) {
+		this.data[t] = this.data[e], delete this.data[e], await this.dump();
+	}
+	async all() {
+		return Object.entries(this.data).map(([e, t]) => ({
+			key: e,
+			value: t
+		}));
+	}
+}, N = "\nCREATE TABLE IF NOT EXISTS kv (\n  key VARCHAR UNIQUE,\n  value VARCHAR\n);\n", P = class e {
+	static async open(t) {
+		return new e(t);
+	}
+	constructor(e) {
+		this.adapter = e, e.exec(N);
+	}
+	async get(e) {
+		return this.adapter.queryRow("SELECT value FROM kv WHERE key=?1", e)?.value;
+	}
+	async set(e, t) {
+		this.adapter.queryRow("INSERT INTO kv(key, value) VALUES(?1, ?2) ON CONFLICT(key) DO UPDATE SET value=?2", e, t);
+	}
+	async keys() {
+		return this.adapter.queryRows("SELECT key FROM kv").map((e) => e.key);
+	}
+	async del(e) {
+		this.adapter.queryRow("DELETE FROM kv WHERE key=?", e);
+	}
+	async rename(e, t) {
+		this.adapter.queryRow("UPDATE kv SET key=?1 WHERE key=?2", t, e);
+	}
+	async all() {
+		return this.adapter.queryRows("SELECT key, value FROM kv");
+	}
 };
+//#endregion
+//#region src/sqlite-common/handler.ts
+function F(e) {
+	return function(t) {
+		let { sql: n, params: r, type: i } = {
+			sql: t.sql,
+			params: t.params ?? [],
+			type: t.type ?? "values"
+		}, a = e(), o = a.prepare(n)[i === "values" ? "values" : "all"](...r);
+		return a.destroy(), o;
+	};
+}
+//#endregion
+export { E as CommandError, j as KvFile, M as KvJson, P as KvSqlite, T as createCGIHandler, w as defaultConfig, k as ensureEnv, A as ensureEnvs, F as getSqlHandler, O as readStdIn, D as runCommand };

package/dist/node/index.js

@@ -1,47 +1,46 @@
-import { DatabaseSync as s } from "node:sqlite";
-class a {
-  constructor(e) {
-    this.statement = e;
-  }
-  get(...e) {
-    return this.statement.get(...e) || void 0;
-  }
-  all(...e) {
-    return this.statement.all(...e);
-  }
-  values(...e) {
-    return this.all(...e).map((t) => Object.values(t));
-  }
-}
-class i {
-  db;
-  constructor(e, t) {
-    this.db = new s(e, t);
-  }
-  exec(e) {
-    if (!this.db) throw new Error("Database is closed");
-    this.db.exec(e);
-  }
-  transaction(e) {
-    throw new Error("Not supported in Node.js");
-  }
-  prepare(e) {
-    if (!this.db) throw new Error("Database is closed");
-    return new a(this.db.prepare(e));
-  }
-  queryRow(e, ...t) {
-    return this.prepare(e).get(...t);
-  }
-  queryRows(e, ...t) {
-    return this.prepare(e).all(...t);
-  }
-  queryValues(e, ...t) {
-    return this.prepare(e).values(...t);
-  }
-  destroy() {
-    this.db?.close();
-  }
-}
-export {
-  i as SqliteAdapter
+import { DatabaseSync as e } from "node:sqlite";
+//#region src/node/sqlite/adapter.ts
+var t = class {
+	constructor(e) {
+		this.statement = e;
+	}
+	get(...e) {
+		return this.statement.get(...e) || void 0;
+	}
+	all(...e) {
+		return this.statement.all(...e);
+	}
+	values(...e) {
+		return this.all(...e).map((e) => Object.values(e));
+	}
+}, n = class {
+	db;
+	constructor(t, n) {
+		this.db = new e(t, n);
+	}
+	exec(e) {
+		if (!this.db) throw Error("Database is closed");
+		this.db.exec(e);
+	}
+	transaction(e) {
+		throw Error("Not supported in Node.js");
+	}
+	prepare(e) {
+		if (!this.db) throw Error("Database is closed");
+		return new t(this.db.prepare(e));
+	}
+	queryRow(e, ...t) {
+		return this.prepare(e).get(...t);
+	}
+	queryRows(e, ...t) {
+		return this.prepare(e).all(...t);
+	}
+	queryValues(e, ...t) {
+		return this.prepare(e).values(...t);
+	}
+	destroy() {
+		this.db?.close();
+	}
 };
+//#endregion
+export { n as SqliteAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gera2ld/common-node",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "exports": {
     ".": {
@@ -20,7 +20,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@gera2ld/common": "^0.0.1"
+    "@gera2ld/common": "^0.0.3"
   },
   "scripts": {
     "clean": "del-cli dist tsconfig.tsbuildinfo",