@soda-gql/common 0.0.1

package/dist/portable-BqSEwase.js

@@ -0,0 +1,249 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region packages/common/src/portable/runtime.ts
+/**
+* Runtime detection utilities for portable API implementation
+*/
+const runtime = {
+	isBun: typeof Bun !== "undefined",
+	isNode: typeof process !== "undefined" && typeof Bun === "undefined",
+	supportsWebCrypto: typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined"
+};
+/**
+* Helper to cache module imports to avoid repeated dynamic imports
+*/
+function once(fn) {
+	let result;
+	let called = false;
+	return () => {
+		if (!called) {
+			result = fn();
+			called = true;
+		}
+		return result;
+	};
+}
+/**
+* Reset runtime state for testing purposes only
+* @internal
+*/
+function resetPortableForTests() {}
+
+//#endregion
+//#region packages/common/src/portable/fs.ts
+const getNodeFS = once(async () => {
+	const fs = await import("node:fs/promises");
+	return fs;
+});
+function createPortableFS() {
+	if (runtime.isBun) {
+		return {
+			async readFile(path) {
+				const file = Bun.file(path);
+				return await file.text();
+			},
+			async writeFile(path, content) {
+				await Bun.write(path, content);
+			},
+			async exists(path) {
+				const nodeFS = await getNodeFS();
+				try {
+					await nodeFS.stat(path);
+					return true;
+				} catch {
+					return false;
+				}
+			},
+			async stat(path) {
+				const file = Bun.file(path);
+				const size = file.size;
+				const nodeFS = await getNodeFS();
+				const { mtime } = await nodeFS.stat(path);
+				return {
+					mtime,
+					size
+				};
+			},
+			async rename(oldPath, newPath) {
+				const nodeFS = await getNodeFS();
+				await nodeFS.rename(oldPath, newPath);
+			},
+			async mkdir(path, options) {
+				const nodeFS = await getNodeFS();
+				await nodeFS.mkdir(path, options);
+			}
+		};
+	}
+	return {
+		async readFile(path) {
+			const nodeFS = await getNodeFS();
+			return await nodeFS.readFile(path, "utf-8");
+		},
+		async writeFile(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathModule = await import("node:path");
+			const dir = pathModule.dirname(path);
+			await nodeFS.mkdir(dir, { recursive: true });
+			await nodeFS.writeFile(path, content, "utf-8");
+		},
+		async exists(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.access(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async stat(path) {
+			const nodeFS = await getNodeFS();
+			const stats = await nodeFS.stat(path);
+			return {
+				mtime: stats.mtime,
+				size: stats.size
+			};
+		},
+		async rename(oldPath, newPath) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.rename(oldPath, newPath);
+		},
+		async mkdir(path, options) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.mkdir(path, options);
+		}
+	};
+}
+let fsInstance = null;
+function getPortableFS() {
+	if (!fsInstance) {
+		fsInstance = createPortableFS();
+	}
+	return fsInstance;
+}
+/**
+* Reset the filesystem singleton for testing
+* @internal
+*/
+function __resetPortableFSForTests() {
+	fsInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/hash.ts
+/**
+* Pads a hex string to the specified length
+*/
+function padHex(hex, length) {
+	return hex.padStart(length, "0");
+}
+function createPortableHasher() {
+	if (runtime.isBun) {
+		return { hash(content, algorithm = "xxhash") {
+			if (algorithm === "sha256") {
+				const hasher = new Bun.CryptoHasher("sha256");
+				hasher.update(content);
+				return hasher.digest("hex");
+			}
+			const hashNum = Bun.hash(content);
+			return padHex(hashNum.toString(16), 16);
+		} };
+	}
+	return { hash(content, algorithm = "xxhash") {
+		if (algorithm === "sha256") {
+			const crypto$2 = __require("node:crypto");
+			return crypto$2.createHash("sha256").update(content).digest("hex");
+		}
+		const crypto$1 = __require("node:crypto");
+		const sha256Hash = crypto$1.createHash("sha256").update(content).digest("hex");
+		return sha256Hash.substring(0, 16);
+	} };
+}
+let hasherInstance = null;
+function getPortableHasher() {
+	if (!hasherInstance) {
+		hasherInstance = createPortableHasher();
+	}
+	return hasherInstance;
+}
+/**
+* Reset the hasher singleton for testing
+* @internal
+*/
+function __resetPortableHasherForTests() {
+	hasherInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/id.ts
+/**
+* Generate a unique ID
+* Uses UUIDv7 on Bun (monotonic), falls back to randomUUID on Node.js
+*/
+function generateId() {
+	if (runtime.isBun && typeof Bun !== "undefined" && typeof Bun.randomUUIDv7 === "function") {
+		return Bun.randomUUIDv7();
+	}
+	const crypto$1 = __require("node:crypto");
+	return crypto$1.randomUUID();
+}
+
+//#endregion
+//#region packages/common/src/portable/spawn.ts
+async function spawn(options) {
+	if (runtime.isBun) {
+		const proc = Bun.spawn(options.cmd, {
+			cwd: options.cwd,
+			env: options.env,
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+		const exitCode = await proc.exited;
+		return {
+			stdout,
+			stderr,
+			exitCode
+		};
+	}
+	const { execFile } = await import("node:child_process");
+	const { promisify } = await import("node:util");
+	const execFilePromise = promisify(execFile);
+	const [command, ...args] = options.cmd;
+	if (!command) {
+		return {
+			stdout: "",
+			stderr: "Error: No command provided",
+			exitCode: 1
+		};
+	}
+	try {
+		const execOptions = { encoding: "utf-8" };
+		if (options.cwd) {
+			execOptions.cwd = options.cwd;
+		}
+		if (options.env) {
+			execOptions.env = options.env;
+		}
+		const { stdout, stderr } = await execFilePromise(command, args, execOptions);
+		return {
+			stdout: stdout || "",
+			stderr: stderr || "",
+			exitCode: 0
+		};
+	} catch (error) {
+		const err = error;
+		return {
+			stdout: err.stdout || "",
+			stderr: err.stderr || "",
+			exitCode: err.code || 1
+		};
+	}
+}
+
+//#endregion
+export { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };
+//# sourceMappingURL=portable-BqSEwase.js.map

package/dist/portable-BqSEwase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable-BqSEwase.js","names":["result: T | undefined","fsInstance: PortableFS | null","crypto","hasherInstance: PortableHasher | null","crypto","execOptions: {\n      cwd?: string;\n      env?: Record<string, string>;\n      encoding: BufferEncoding;\n    }","error: unknown"],"sources":["../src/portable/runtime.ts","../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/id.ts","../src/portable/spawn.ts"],"sourcesContent":["/**\n * Runtime detection utilities for portable API implementation\n */\n\nexport const runtime = {\n  isBun: typeof Bun !== \"undefined\",\n  isNode: typeof process !== \"undefined\" && typeof Bun === \"undefined\",\n  supportsWebCrypto: typeof crypto !== \"undefined\" && typeof crypto.subtle !== \"undefined\",\n} as const;\n\n/**\n * Helper to cache module imports to avoid repeated dynamic imports\n */\nexport function once<T>(fn: () => T): () => T {\n  let result: T | undefined;\n  let called = false;\n\n  return () => {\n    if (!called) {\n      result = fn();\n      called = true;\n    }\n    return result as T;\n  };\n}\n\n/**\n * Reset runtime state for testing purposes only\n * @internal\n */\nexport function resetPortableForTests(): void {\n  // This is a marker function that portable modules can use\n  // to reset their singleton state in tests\n}\n","/**\n * Portable filesystem API that works on both Bun and Node.js\n */\n\nimport { once, runtime } from \"./runtime\";\n\nexport interface PortableFS {\n  readFile(path: string): Promise<string>;\n  writeFile(path: string, content: string): Promise<void>;\n  exists(path: string): Promise<boolean>;\n  stat(path: string): Promise<{ mtime: Date; size: number }>;\n  rename(oldPath: string, newPath: string): Promise<void>;\n  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;\n}\n\ninterface FSPromises {\n  readFile: (path: string, encoding: string) => Promise<string>;\n  writeFile: (path: string, content: string, encoding: string) => Promise<void>;\n  access: (path: string) => Promise<void>;\n  stat: (path: string) => Promise<{\n    mtime: Date;\n    size: number;\n    isDirectory: () => boolean;\n  }>;\n  rename: (oldPath: string, newPath: string) => Promise<void>;\n  mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n}\n\n// Cache the fs/promises import\nconst getNodeFS = once(async (): Promise<FSPromises> => {\n  const fs = await import(\"node:fs/promises\");\n  return fs as FSPromises;\n});\n\nexport function createPortableFS(): PortableFS {\n  if (runtime.isBun) {\n    return {\n      async readFile(path) {\n        const file = Bun.file(path);\n        return await file.text();\n      },\n\n      async writeFile(path, content) {\n        // Bun.write auto-creates parent directories\n        await Bun.write(path, content);\n      },\n\n      async exists(path) {\n        // Bun.file().exists() only works for files, use fs.stat for both files and dirs\n        const nodeFS = await getNodeFS();\n        try {\n          await nodeFS.stat(path);\n          return true;\n        } catch {\n          return false;\n        }\n      },\n\n      async stat(path) {\n        const file = Bun.file(path);\n        const size = file.size;\n        // Bun doesn't expose mtime directly, use Node fs.stat\n        const nodeFS = await getNodeFS();\n        const { mtime } = await nodeFS.stat(path);\n        return { mtime, size };\n      },\n\n      async rename(oldPath, newPath) {\n        const nodeFS = await getNodeFS();\n        await nodeFS.rename(oldPath, newPath);\n      },\n\n      async mkdir(path, options) {\n        const nodeFS = await getNodeFS();\n        await nodeFS.mkdir(path, options);\n      },\n    };\n  }\n\n  // Node.js implementation\n  return {\n    async readFile(path) {\n      const nodeFS = await getNodeFS();\n      return await nodeFS.readFile(path, \"utf-8\");\n    },\n\n    async writeFile(path, content) {\n      const nodeFS = await getNodeFS();\n      // Auto-create parent directories like Bun.write does\n      const pathModule = await import(\"node:path\");\n      const dir = pathModule.dirname(path);\n      await nodeFS.mkdir(dir, { recursive: true });\n      await nodeFS.writeFile(path, content, \"utf-8\");\n    },\n\n    async exists(path) {\n      const nodeFS = await getNodeFS();\n      try {\n        await nodeFS.access(path);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n\n    async stat(path) {\n      const nodeFS = await getNodeFS();\n      const stats = await nodeFS.stat(path);\n      return { mtime: stats.mtime, size: stats.size };\n    },\n\n    async rename(oldPath, newPath) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.rename(oldPath, newPath);\n    },\n\n    async mkdir(path, options) {\n      const nodeFS = await getNodeFS();\n      await nodeFS.mkdir(path, options);\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet fsInstance: PortableFS | null = null;\n\nexport function getPortableFS(): PortableFS {\n  if (!fsInstance) {\n    fsInstance = createPortableFS();\n  }\n  return fsInstance;\n}\n\n/**\n * Reset the filesystem singleton for testing\n * @internal\n */\nexport function __resetPortableFSForTests(): void {\n  fsInstance = null;\n}\n","/**\n * Portable hashing API that works on both Bun and Node.js\n */\n\nimport { runtime } from \"./runtime\";\n\nexport type HashAlgorithm = \"sha256\" | \"xxhash\";\n\nexport interface PortableHasher {\n  hash(content: string, algorithm?: HashAlgorithm): string;\n}\n\n/**\n * Pads a hex string to the specified length\n */\nfunction padHex(hex: string, length: number): string {\n  return hex.padStart(length, \"0\");\n}\n\nexport function createPortableHasher(): PortableHasher {\n  if (runtime.isBun) {\n    return {\n      hash(content, algorithm = \"xxhash\") {\n        if (algorithm === \"sha256\") {\n          const hasher = new Bun.CryptoHasher(\"sha256\");\n          hasher.update(content);\n          return hasher.digest(\"hex\");\n        }\n        // xxhash - Bun.hash returns a number\n        const hashNum = Bun.hash(content);\n        // Convert to hex and pad to 16 chars for consistency\n        return padHex(hashNum.toString(16), 16);\n      },\n    };\n  }\n\n  // Node.js implementation\n  return {\n    hash(content, algorithm = \"xxhash\") {\n      if (algorithm === \"sha256\") {\n        const crypto = require(\"node:crypto\");\n        return crypto.createHash(\"sha256\").update(content).digest(\"hex\");\n      }\n      // xxhash fallback: use sha256 for now (can add xxhash package later if needed)\n      // This ensures consistent behavior across runtimes\n      const crypto = require(\"node:crypto\");\n      const sha256Hash = crypto.createHash(\"sha256\").update(content).digest(\"hex\");\n      // Take first 16 chars to match xxhash output length\n      return sha256Hash.substring(0, 16);\n    },\n  };\n}\n\n// Singleton to avoid recreating instances\nlet hasherInstance: PortableHasher | null = null;\n\nexport function getPortableHasher(): PortableHasher {\n  if (!hasherInstance) {\n    hasherInstance = createPortableHasher();\n  }\n  return hasherInstance;\n}\n\n/**\n * Reset the hasher singleton for testing\n * @internal\n */\nexport function __resetPortableHasherForTests(): void {\n  hasherInstance = null;\n}\n","/**\n * Portable ID generation that works on both Bun and Node.js\n */\n\nimport { runtime } from \"./runtime\";\n\n/**\n * Generate a unique ID\n * Uses UUIDv7 on Bun (monotonic), falls back to randomUUID on Node.js\n */\nexport function generateId(): string {\n  if (runtime.isBun && typeof Bun !== \"undefined\" && typeof Bun.randomUUIDv7 === \"function\") {\n    return Bun.randomUUIDv7();\n  }\n\n  // Node.js fallback: use crypto.randomUUID\n  const crypto = require(\"node:crypto\");\n  return crypto.randomUUID();\n}\n","/**\n * Portable subprocess spawning that works on both Bun and Node.js\n */\n\nimport { runtime } from \"./runtime\";\n\nexport interface SpawnOptions {\n  cmd: string[];\n  cwd?: string;\n  env?: Record<string, string>;\n}\n\nexport interface SpawnResult {\n  stdout: string;\n  stderr: string;\n  exitCode: number;\n}\n\nexport async function spawn(options: SpawnOptions): Promise<SpawnResult> {\n  if (runtime.isBun) {\n    const proc = Bun.spawn(options.cmd, {\n      cwd: options.cwd,\n      env: options.env,\n      stdout: \"pipe\",\n      stderr: \"pipe\",\n    });\n\n    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);\n\n    const exitCode = await proc.exited;\n\n    return { stdout, stderr, exitCode };\n  }\n\n  // Node.js implementation\n  const { execFile } = await import(\"node:child_process\");\n  const { promisify } = await import(\"node:util\");\n  const execFilePromise = promisify(execFile);\n\n  const [command, ...args] = options.cmd;\n  if (!command) {\n    return {\n      stdout: \"\",\n      stderr: \"Error: No command provided\",\n      exitCode: 1,\n    };\n  }\n\n  try {\n    const execOptions: {\n      cwd?: string;\n      env?: Record<string, string>;\n      encoding: BufferEncoding;\n    } = {\n      encoding: \"utf-8\",\n    };\n\n    if (options.cwd) {\n      execOptions.cwd = options.cwd;\n    }\n    if (options.env) {\n      execOptions.env = options.env;\n    }\n\n    const { stdout, stderr } = await execFilePromise(command, args, execOptions);\n    return {\n      stdout: stdout || \"\",\n      stderr: stderr || \"\",\n      exitCode: 0,\n    };\n  } catch (error: unknown) {\n    const err = error as {\n      stdout?: string;\n      stderr?: string;\n      code?: number;\n    };\n    return {\n      stdout: err.stdout || \"\",\n      stderr: err.stderr || \"\",\n      exitCode: err.code || 1,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/portable-Bq_Qob6b.cjs

@@ -0,0 +1,308 @@
+
+//#region packages/common/src/portable/runtime.ts
+/**
+* Runtime detection utilities for portable API implementation
+*/
+const runtime = {
+	isBun: typeof Bun !== "undefined",
+	isNode: typeof process !== "undefined" && typeof Bun === "undefined",
+	supportsWebCrypto: typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined"
+};
+/**
+* Helper to cache module imports to avoid repeated dynamic imports
+*/
+function once(fn) {
+	let result;
+	let called = false;
+	return () => {
+		if (!called) {
+			result = fn();
+			called = true;
+		}
+		return result;
+	};
+}
+/**
+* Reset runtime state for testing purposes only
+* @internal
+*/
+function resetPortableForTests() {}
+
+//#endregion
+//#region packages/common/src/portable/fs.ts
+const getNodeFS = once(async () => {
+	const fs = await import("node:fs/promises");
+	return fs;
+});
+function createPortableFS() {
+	if (runtime.isBun) {
+		return {
+			async readFile(path) {
+				const file = Bun.file(path);
+				return await file.text();
+			},
+			async writeFile(path, content) {
+				await Bun.write(path, content);
+			},
+			async exists(path) {
+				const nodeFS = await getNodeFS();
+				try {
+					await nodeFS.stat(path);
+					return true;
+				} catch {
+					return false;
+				}
+			},
+			async stat(path) {
+				const file = Bun.file(path);
+				const size = file.size;
+				const nodeFS = await getNodeFS();
+				const { mtime } = await nodeFS.stat(path);
+				return {
+					mtime,
+					size
+				};
+			},
+			async rename(oldPath, newPath) {
+				const nodeFS = await getNodeFS();
+				await nodeFS.rename(oldPath, newPath);
+			},
+			async mkdir(path, options) {
+				const nodeFS = await getNodeFS();
+				await nodeFS.mkdir(path, options);
+			}
+		};
+	}
+	return {
+		async readFile(path) {
+			const nodeFS = await getNodeFS();
+			return await nodeFS.readFile(path, "utf-8");
+		},
+		async writeFile(path, content) {
+			const nodeFS = await getNodeFS();
+			const pathModule = await import("node:path");
+			const dir = pathModule.dirname(path);
+			await nodeFS.mkdir(dir, { recursive: true });
+			await nodeFS.writeFile(path, content, "utf-8");
+		},
+		async exists(path) {
+			const nodeFS = await getNodeFS();
+			try {
+				await nodeFS.access(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async stat(path) {
+			const nodeFS = await getNodeFS();
+			const stats = await nodeFS.stat(path);
+			return {
+				mtime: stats.mtime,
+				size: stats.size
+			};
+		},
+		async rename(oldPath, newPath) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.rename(oldPath, newPath);
+		},
+		async mkdir(path, options) {
+			const nodeFS = await getNodeFS();
+			await nodeFS.mkdir(path, options);
+		}
+	};
+}
+let fsInstance = null;
+function getPortableFS() {
+	if (!fsInstance) {
+		fsInstance = createPortableFS();
+	}
+	return fsInstance;
+}
+/**
+* Reset the filesystem singleton for testing
+* @internal
+*/
+function __resetPortableFSForTests() {
+	fsInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/hash.ts
+/**
+* Pads a hex string to the specified length
+*/
+function padHex(hex, length) {
+	return hex.padStart(length, "0");
+}
+function createPortableHasher() {
+	if (runtime.isBun) {
+		return { hash(content, algorithm = "xxhash") {
+			if (algorithm === "sha256") {
+				const hasher = new Bun.CryptoHasher("sha256");
+				hasher.update(content);
+				return hasher.digest("hex");
+			}
+			const hashNum = Bun.hash(content);
+			return padHex(hashNum.toString(16), 16);
+		} };
+	}
+	return { hash(content, algorithm = "xxhash") {
+		if (algorithm === "sha256") {
+			const crypto$2 = require("node:crypto");
+			return crypto$2.createHash("sha256").update(content).digest("hex");
+		}
+		const crypto$1 = require("node:crypto");
+		const sha256Hash = crypto$1.createHash("sha256").update(content).digest("hex");
+		return sha256Hash.substring(0, 16);
+	} };
+}
+let hasherInstance = null;
+function getPortableHasher() {
+	if (!hasherInstance) {
+		hasherInstance = createPortableHasher();
+	}
+	return hasherInstance;
+}
+/**
+* Reset the hasher singleton for testing
+* @internal
+*/
+function __resetPortableHasherForTests() {
+	hasherInstance = null;
+}
+
+//#endregion
+//#region packages/common/src/portable/id.ts
+/**
+* Generate a unique ID
+* Uses UUIDv7 on Bun (monotonic), falls back to randomUUID on Node.js
+*/
+function generateId() {
+	if (runtime.isBun && typeof Bun !== "undefined" && typeof Bun.randomUUIDv7 === "function") {
+		return Bun.randomUUIDv7();
+	}
+	const crypto$1 = require("node:crypto");
+	return crypto$1.randomUUID();
+}
+
+//#endregion
+//#region packages/common/src/portable/spawn.ts
+async function spawn(options) {
+	if (runtime.isBun) {
+		const proc = Bun.spawn(options.cmd, {
+			cwd: options.cwd,
+			env: options.env,
+			stdout: "pipe",
+			stderr: "pipe"
+		});
+		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+		const exitCode = await proc.exited;
+		return {
+			stdout,
+			stderr,
+			exitCode
+		};
+	}
+	const { execFile } = await import("node:child_process");
+	const { promisify } = await import("node:util");
+	const execFilePromise = promisify(execFile);
+	const [command, ...args] = options.cmd;
+	if (!command) {
+		return {
+			stdout: "",
+			stderr: "Error: No command provided",
+			exitCode: 1
+		};
+	}
+	try {
+		const execOptions = { encoding: "utf-8" };
+		if (options.cwd) {
+			execOptions.cwd = options.cwd;
+		}
+		if (options.env) {
+			execOptions.env = options.env;
+		}
+		const { stdout, stderr } = await execFilePromise(command, args, execOptions);
+		return {
+			stdout: stdout || "",
+			stderr: stderr || "",
+			exitCode: 0
+		};
+	} catch (error) {
+		const err = error;
+		return {
+			stdout: err.stdout || "",
+			stderr: err.stderr || "",
+			exitCode: err.code || 1
+		};
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, '__resetPortableFSForTests', {
+  enumerable: true,
+  get: function () {
+    return __resetPortableFSForTests;
+  }
+});
+Object.defineProperty(exports, '__resetPortableHasherForTests', {
+  enumerable: true,
+  get: function () {
+    return __resetPortableHasherForTests;
+  }
+});
+Object.defineProperty(exports, 'createPortableFS', {
+  enumerable: true,
+  get: function () {
+    return createPortableFS;
+  }
+});
+Object.defineProperty(exports, 'createPortableHasher', {
+  enumerable: true,
+  get: function () {
+    return createPortableHasher;
+  }
+});
+Object.defineProperty(exports, 'generateId', {
+  enumerable: true,
+  get: function () {
+    return generateId;
+  }
+});
+Object.defineProperty(exports, 'getPortableFS', {
+  enumerable: true,
+  get: function () {
+    return getPortableFS;
+  }
+});
+Object.defineProperty(exports, 'getPortableHasher', {
+  enumerable: true,
+  get: function () {
+    return getPortableHasher;
+  }
+});
+Object.defineProperty(exports, 'once', {
+  enumerable: true,
+  get: function () {
+    return once;
+  }
+});
+Object.defineProperty(exports, 'resetPortableForTests', {
+  enumerable: true,
+  get: function () {
+    return resetPortableForTests;
+  }
+});
+Object.defineProperty(exports, 'runtime', {
+  enumerable: true,
+  get: function () {
+    return runtime;
+  }
+});
+Object.defineProperty(exports, 'spawn', {
+  enumerable: true,
+  get: function () {
+    return spawn;
+  }
+});

package/dist/utils/index.cjs

@@ -0,0 +1,9 @@
+const require_utils = require('../utils-NBAPoMgh.cjs');
+
+exports.MODULE_EXTENSION_CANDIDATES = require_utils.MODULE_EXTENSION_CANDIDATES;
+exports.cachedFn = require_utils.cachedFn;
+exports.isExternalSpecifier = require_utils.isExternalSpecifier;
+exports.isRelativeSpecifier = require_utils.isRelativeSpecifier;
+exports.normalizePath = require_utils.normalizePath;
+exports.resolveRelativeImportWithExistenceCheck = require_utils.resolveRelativeImportWithExistenceCheck;
+exports.resolveRelativeImportWithReferences = require_utils.resolveRelativeImportWithReferences;

package/dist/utils/index.d.cts

@@ -0,0 +1,2 @@
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "../index-Fi3RpHje.cjs";
+export { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences };

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "../index-CcSB32XQ.js";
+export { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences };

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "../utils-DxBnV8tL.js";
+
+export { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences };