yamlite 0.0.0-stage → 0.35.0

package/dist/browser/aliases.d.mts

@@ -0,0 +1,6 @@
+//#region src/browser/aliases.d.ts
+export declare function browserAliases(): {
+  find: RegExp;
+  replacement: string;
+}[];
+//#endregion

package/dist/browser/aliases.mjs

@@ -0,0 +1,42 @@
+import { fileURLToPath } from "node:url";
+//#region src/browser/aliases.ts
+const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".mjs";
+const here = (name) => fileURLToPath(new URL(`./${name}${ext}`, import.meta.url));
+function browserAliases() {
+	return [
+		{
+			find: /^node:sqlite$/,
+			replacement: here("sqlite")
+		},
+		{
+			find: /^node:fs$/,
+			replacement: here("fs")
+		},
+		{
+			find: /^(node:)?path$/,
+			replacement: here("path")
+		},
+		{
+			find: /^node:os$/,
+			replacement: here("os")
+		},
+		{
+			find: /^node:crypto$/,
+			replacement: here("crypto")
+		},
+		{
+			find: /^(node:url|node:child_process|node:stream|node:http|node:util|node:module)$/,
+			replacement: here("unavailable")
+		},
+		{
+			find: /^chokidar$/,
+			replacement: here("chokidar")
+		},
+		{
+			find: /^buffer$/,
+			replacement: fileURLToPath(import.meta.resolve("buffer/index.js"))
+		}
+	];
+}
+//#endregion
+export { browserAliases };

package/dist/browser/chokidar.d.mts

@@ -0,0 +1,17 @@
+//#region src/browser/chokidar.d.ts
+type Listener = (...args: any[]) => void;
+export interface FSWatcher {
+  on(event: string, fn: Listener): FSWatcher;
+  once(event: string, fn: Listener): FSWatcher;
+  add(paths: string | string[]): FSWatcher;
+  unwatch(paths: string | string[]): FSWatcher;
+  close(): Promise<void>;
+}
+interface Options {
+  depth?: number;
+  ignored?: (path: string) => boolean;
+  ignoreInitial?: boolean;
+}
+export declare function watch(paths: string | string[], opts?: Options): FSWatcher;
+//#endregion
+export {};

package/dist/browser/chokidar.mjs

@@ -0,0 +1,64 @@
+import { p as onChange } from "../fs-DZ4QHM93.mjs";
+import { resolve } from "pathe";
+//#region src/browser/chokidar.ts
+const list = (paths) => (Array.isArray(paths) ? paths : [paths]).map((p) => resolve(p));
+const below = (root, path) => {
+	if (path === root) return [];
+	const prefix = root === "/" ? "/" : `${root}/`;
+	return path.startsWith(prefix) ? path.slice(prefix.length).split("/") : null;
+};
+function watch(paths, opts = {}) {
+	const roots = new Set(list(paths));
+	const listeners = /* @__PURE__ */ new Map();
+	let closed = false;
+	const fire = (event, ...args) => {
+		for (const fn of Array.from(listeners.get(event) ?? [])) fn(...args);
+	};
+	const wanted = (path) => [...roots].some((root) => {
+		const parts = below(root, path);
+		if (!parts) return false;
+		if (opts.depth !== void 0 && parts.length > 0 && parts.length - 1 > opts.depth) return false;
+		let at = root;
+		return !parts.some((part) => {
+			at = at === "/" ? `/${part}` : `${at}/${part}`;
+			return opts.ignored?.(at);
+		});
+	});
+	const off = onChange((event, path) => {
+		if (closed || !wanted(path)) return;
+		fire(event, path);
+		fire("all", event, path);
+	});
+	const w = {
+		on(event, fn) {
+			const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+			set.add(fn);
+			listeners.set(event, set);
+			return w;
+		},
+		once(event, fn) {
+			const wrapped = (...args) => {
+				listeners.get(event)?.delete(wrapped);
+				fn(...args);
+			};
+			return w.on(event, wrapped);
+		},
+		add(p) {
+			for (const x of list(p)) roots.add(x);
+			return w;
+		},
+		unwatch(p) {
+			for (const x of list(p)) roots.delete(x);
+			return w;
+		},
+		async close() {
+			closed = true;
+			off();
+			listeners.clear();
+		}
+	};
+	queueMicrotask(() => !closed && fire("ready"));
+	return w;
+}
+//#endregion
+export { watch };

package/dist/browser/crypto.d.mts

@@ -0,0 +1,11 @@
+//#region src/browser/crypto.d.ts
+export declare function createHash(alg: string): {
+  update(data: string | Uint8Array): {
+    update(data: string | Uint8Array): /*elided*/ any;
+    digest(enc: "hex"): string;
+  };
+  digest(enc: "hex"): string;
+};
+export declare const randomBytes: (n: number) => Buffer<ArrayBuffer>;
+export declare const timingSafeEqual: (a: Uint8Array, b: Uint8Array) => boolean;
+//#endregion

package/dist/browser/crypto.mjs

@@ -0,0 +1,27 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
+//#region src/browser/crypto.ts
+function createHash(alg) {
+	if (alg !== "sha256") throw new Error(`createHash(${alg}) is not available in the browser build`);
+	const parts = [];
+	return {
+		update(data) {
+			parts.push(typeof data === "string" ? utf8ToBytes(data) : data);
+			return this;
+		},
+		digest(enc) {
+			const all = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+			let at = 0;
+			for (const p of parts) {
+				all.set(p, at);
+				at += p.length;
+			}
+			if (enc !== "hex") throw new Error("only hex digests");
+			return bytesToHex(sha256(all));
+		}
+	};
+}
+const randomBytes = (n) => Buffer.from(crypto.getRandomValues(new Uint8Array(n)));
+const timingSafeEqual = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+//#endregion
+export { createHash, randomBytes, timingSafeEqual };

package/dist/browser/expose.d.mts

@@ -0,0 +1,3 @@
+//#region src/browser/expose.d.ts
+export declare function expose(port: MessagePort, dispatch: (r: Request) => Promise<Response>): () => void;
+//#endregion

package/dist/browser/expose.mjs

@@ -0,0 +1,80 @@
+//#region src/browser/expose.ts
+function expose(port, dispatch) {
+	const open = /* @__PURE__ */ new Map();
+	port.onmessage = async (e) => {
+		const m = e.data;
+		if (m.kind === "abort") {
+			open.get(m.id)?.abort();
+			return;
+		}
+		const ac = new AbortController();
+		open.set(m.id, ac);
+		let headSent = false;
+		try {
+			const res = await dispatch(new Request(new URL(m.url, "http://worker"), {
+				method: m.method,
+				headers: m.headers,
+				body: m.body,
+				signal: ac.signal
+			}));
+			if (ac.signal.aborted) {
+				res.body?.cancel();
+				return;
+			}
+			port.postMessage({
+				id: m.id,
+				kind: "head",
+				status: res.status,
+				headers: [...res.headers]
+			});
+			headSent = true;
+			if (res.body) {
+				const decoder = new TextDecoder();
+				const reader = res.body.getReader();
+				ac.signal.addEventListener("abort", () => void reader.cancel(), { once: true });
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					port.postMessage({
+						id: m.id,
+						kind: "chunk",
+						data: decoder.decode(value, { stream: true })
+					});
+				}
+				const rest = decoder.decode();
+				if (rest) port.postMessage({
+					id: m.id,
+					kind: "chunk",
+					data: rest
+				});
+			}
+		} catch (err) {
+			if (!ac.signal.aborted && !headSent) {
+				port.postMessage({
+					id: m.id,
+					kind: "head",
+					status: 500,
+					headers: [["content-type", "application/json"]]
+				});
+				port.postMessage({
+					id: m.id,
+					kind: "chunk",
+					data: JSON.stringify({ error: String(err) })
+				});
+			}
+		} finally {
+			open.delete(m.id);
+			port.postMessage({
+				id: m.id,
+				kind: "end"
+			});
+		}
+	};
+	port.start?.();
+	return () => {
+		for (const ac of open.values()) ac.abort();
+		port.onmessage = null;
+	};
+}
+//#endregion
+export { expose };

package/dist/browser/fs.d.mts

@@ -0,0 +1,85 @@
+//#region src/browser/fs.d.ts
+export type FsEvent = "add" | "change" | "unlink" | "addDir" | "unlinkDir";
+export declare function onChange(fn: (event: FsEvent, path: string) => void): () => void;
+export declare function onRemove(fn: (path: string) => void): void;
+export declare function external(fn: (path: string) => boolean): void;
+export declare const constants: {
+  F_OK: number;
+  R_OK: number;
+  W_OK: number;
+  X_OK: number;
+};
+export declare const existsSync: (p: string) => boolean;
+export declare function statSync(p: string, opts?: {
+  throwIfNoEntry?: boolean;
+}): {
+  isDirectory: () => boolean;
+  isFile: () => boolean;
+  isSymbolicLink: () => boolean;
+  mtimeMs: number;
+  mtime: Date;
+  size: number;
+  mode: number;
+} | undefined;
+export declare const lstatSync: typeof statSync;
+export declare function accessSync(p: string): void;
+export declare function realpathSync(p: string): string;
+export declare function readFileSync(p: string, opts?: string | {
+  encoding?: string;
+}): string | Buffer<ArrayBuffer>;
+export declare function writeFileSync(p: string, content: string | Uint8Array, opts?: {
+  flag?: string;
+} | string): void;
+export declare function mkdirSync(p: string, opts?: {
+  recursive?: boolean;
+}): string | undefined;
+export declare function readdirSync(p: string, opts?: {
+  withFileTypes?: boolean;
+}): string[] | {
+  name: string;
+  parentPath: string;
+  path: string;
+  isDirectory: () => boolean;
+  isFile: () => boolean;
+  isSymbolicLink: () => boolean;
+}[];
+export declare function unlinkSync(p: string): void;
+export declare function rmdirSync(p: string): void;
+export declare function rmSync(p: string, opts?: {
+  recursive?: boolean;
+  force?: boolean;
+}): void;
+export declare function renameSync(from: string, to: string): void;
+export declare function linkSync(from: string, to: string): void;
+export declare function cpSync(from: string, to: string): void;
+export declare function chmodSync(p: string, mode: number): void;
+export declare function mkdtempSync(prefix: string): string;
+export declare function createReadStream(): never;
+declare const _default: {
+  accessSync: typeof accessSync;
+  chmodSync: typeof chmodSync;
+  constants: {
+    F_OK: number;
+    R_OK: number;
+    W_OK: number;
+    X_OK: number;
+  };
+  cpSync: typeof cpSync;
+  createReadStream: typeof createReadStream;
+  existsSync: typeof existsSync;
+  linkSync: typeof linkSync;
+  lstatSync: typeof statSync;
+  mkdirSync: typeof mkdirSync;
+  mkdtempSync: typeof mkdtempSync;
+  readdirSync: typeof readdirSync;
+  readFileSync: typeof readFileSync;
+  realpathSync: typeof realpathSync;
+  renameSync: typeof renameSync;
+  rmdirSync: typeof rmdirSync;
+  rmSync: typeof rmSync;
+  statSync: typeof statSync;
+  unlinkSync: typeof unlinkSync;
+  writeFileSync: typeof writeFileSync;
+};
+//#endregion
+export { _default as default };

package/dist/browser/fs.mjs

@@ -0,0 +1 @@
+export { t as accessSync, n as chmodSync, r as constants, i as cpSync, a as createReadStream, c as default, o as existsSync, s as external, l as linkSync, u as lstatSync, d as mkdirSync, f as mkdtempSync, p as onChange, m as onRemove, h as readFileSync, g as readdirSync, _ as realpathSync, v as renameSync, y as rmSync, b as rmdirSync, x as statSync, S as unlinkSync, C as writeFileSync } from "../fs-DZ4QHM93.mjs";

package/dist/browser/globals.d.mts

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

package/dist/browser/globals.mjs

@@ -0,0 +1,21 @@
+import { Buffer } from "buffer";
+//#region src/browser/globals.ts
+const g = globalThis;
+g.Buffer ??= Buffer;
+g.global ??= globalThis;
+g.process ??= {
+	env: {},
+	pid: 1,
+	platform: "browser",
+	argv: [],
+	versions: {},
+	cwd: () => "/",
+	kill: () => true,
+	nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),
+	emitWarning: () => {},
+	on: () => {},
+	once: () => {},
+	getuid: () => 1e3
+};
+//#endregion
+export {};

package/dist/browser/os.d.mts

@@ -0,0 +1,9 @@
+//#region src/browser/os.d.ts
+export declare const tmpdir: () => string;
+export declare const homedir: () => string;
+declare const _default: {
+  tmpdir: typeof tmpdir;
+  homedir: typeof homedir;
+};
+//#endregion
+export { _default as default };

package/dist/browser/os.mjs

@@ -0,0 +1,9 @@
+//#region src/browser/os.ts
+const tmpdir = () => "/tmp";
+const homedir = () => "/home";
+var os_default = {
+	tmpdir,
+	homedir
+};
+//#endregion
+export { os_default as default, homedir, tmpdir };

package/dist/browser/path.d.mts

@@ -0,0 +1,28 @@
+import * as pathe from "pathe";
+export * from "pathe";
+//#region src/browser/path.d.ts
+export declare const posix: typeof pathe;
+export declare const delimiter = ":";
+export declare const matchesGlob: (path: string, glob: string) => boolean;
+declare const _default: {
+  basename: typeof import("node:path").basename;
+  default: typeof import("node:path");
+  dirname: typeof import("node:path").dirname;
+  extname: typeof import("node:path").extname;
+  format: typeof import("node:path").format;
+  isAbsolute: typeof import("node:path").isAbsolute;
+  join: typeof import("node:path").join;
+  normalize: typeof import("node:path").normalize;
+  normalizeString: typeof pathe.normalizeString;
+  parse: typeof import("node:path").parse;
+  relative: typeof import("node:path").relative;
+  resolve: typeof import("node:path").resolve;
+  sep: "/";
+  toNamespacedPath: typeof import("node:path").toNamespacedPath;
+  win32: typeof import("node:path");
+  posix: typeof pathe;
+  delimiter: string;
+  matchesGlob: typeof matchesGlob;
+};
+//#endregion
+export { _default as default };

package/dist/browser/path.mjs

@@ -0,0 +1,15 @@
+import * as pathe from "pathe";
+import picomatch from "picomatch";
+export * from "pathe";
+//#region src/browser/path.ts
+const posix = pathe;
+const delimiter = ":";
+const matchesGlob = (path, glob) => picomatch(glob, { dot: true })(path);
+var path_default = {
+	...pathe,
+	posix: pathe,
+	delimiter: ":",
+	matchesGlob
+};
+//#endregion
+export { path_default as default, delimiter, matchesGlob, posix };

package/dist/browser/sqlite.d.mts

@@ -0,0 +1,48 @@
+//#region src/browser/sqlite.d.ts
+export declare const sqlite3: any;
+export declare const opfs: any;
+export declare function registerVfs(name: string): void;
+type Value = null | number | bigint | string | Uint8Array;
+type Row = Record<string, Value>;
+export declare const constants: Record<string, number>;
+export declare class StatementSync {
+  private readonly db;
+  private readonly stmt;
+  private bigInts;
+  private arrays;
+  constructor(db: any, stmt: any, open: Set<any>);
+  setReadBigInts(on: boolean): void;
+  setReturnArrays(on: boolean): void;
+  columns(): Array<{
+    name: string;
+    type: string | null;
+  }>;
+  private bind;
+  private row;
+  private step;
+  all(...params: unknown[]): (Value[] | Row)[];
+  get(...params: unknown[]): Value[] | Row | undefined;
+  iterate(...params: unknown[]): Generator<Value[] | Row, void, unknown>;
+  run(...params: unknown[]): {
+    changes: bigint;
+    lastInsertRowid: bigint;
+  } | {
+    changes: number;
+    lastInsertRowid: number;
+  };
+}
+export declare class DatabaseSync {
+  private readonly db;
+  private readonly stmts;
+  constructor(path: string, opts?: {
+    readOnly?: boolean;
+  });
+  get isOpen(): boolean;
+  get isTransaction(): boolean;
+  exec(sql: string): void;
+  prepare(sql: string): StatementSync;
+  setAuthorizer(fn: ((action: number, ...args: Array<string | null>) => number) | null): void;
+  close(): void;
+}
+//#endregion
+export {};