zstd-stream 1.0.0

package/dist/loader.d.ts

@@ -0,0 +1,3 @@
+import type { Module } from "./types.ts";
+export declare function initZstd(): Promise<void>;
+export declare function getModule(): Module;

package/dist/loader.js

@@ -0,0 +1,106 @@
+import { lib } from "./lib.js";
+let module = null;
+let initPromise = null;
+const isNode = typeof process !== "undefined" && process.versions?.node != null;
+async function loadGzipped() {
+    if (isNode) {
+        // Node.js path
+        const { gunzip } = await import("node:zlib");
+        const { promisify } = await import("node:util");
+        const binaryData = Buffer.from(lib, "base64");
+        const decompressed = await promisify(gunzip)(binaryData);
+        return decompressed.toString("utf-8");
+    }
+    // Browser path
+    const binaryString = atob(lib);
+    const binaryData = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    const stream = new Blob([binaryData])
+        .stream()
+        .pipeThrough(new DecompressionStream("gzip"));
+    const buffer = await new Response(stream).arrayBuffer();
+    return new TextDecoder().decode(buffer);
+}
+async function evaluateCode(code) {
+    if (isNode) {
+        try {
+            // Try using data URL import (works in Node.js v22+)
+            const url = `data:text/javascript,${encodeURIComponent(code)}`;
+            const mod = await import(/* @vite-ignore */ url);
+            return mod.default || mod.ZstdWasm || mod;
+        }
+        catch (e) {
+            if (e.code !== "ERR_UNKNOWN_FILE_EXTENSION") {
+                console.debug("Data URL import failed:", e?.message);
+            }
+            const vm = await import("node:vm");
+            // Create a context with required globals
+            const context = vm.createContext({
+                ...globalThis, // Start with real globals
+                // Override only what's needed
+                console,
+                TextEncoder,
+                TextDecoder,
+            });
+            // Create and evaluate as ESM
+            const mod = new vm.SourceTextModule(code, {
+                context,
+                identifier: "zstd-bundle.js",
+                importModuleDynamically: async (specifier) => {
+                    // Allow dynamic ESM imports (e.g., import("node:buffer"))
+                    // Most embedded bundles won't use this, but safe to allow
+                    try {
+                        return await import(/* @vite-ignore */ specifier);
+                    }
+                    catch (e) {
+                        console.warn(`⚠️ Dynamic import failed: ${specifier}`, e.message);
+                        throw new Error(`Dynamic import not supported: ${specifier}`);
+                    }
+                },
+            });
+            // Link — since it's a self-contained bundle, it likely has no static imports
+            // If it does, you'd need a resolver — but most don't
+            await mod.link((specifier) => {
+                throw new Error(`Static import not supported: ${specifier}`);
+            });
+            await mod.evaluate();
+            const ns = mod.namespace;
+            return ns.default || ns.ZstdWasm || ns;
+        }
+    }
+    // Browser path — unchanged
+    const { URL } = globalThis;
+    const blob = new Blob([code], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    try {
+        const mod = await import(/* @vite-ignore */ url);
+        return mod.default || mod.ZstdWasm || mod;
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}
+export async function initZstd() {
+    if (initPromise)
+        return initPromise;
+    if (module)
+        return;
+    initPromise = (async () => {
+        try {
+            const code = await loadGzipped();
+            const loader = await evaluateCode(code);
+            module = await loader();
+            if (!module)
+                throw new Error("WASM module initialization returned null");
+        }
+        catch (error) {
+            initPromise = null;
+            throw new Error(`Failed to initialize Zstandard: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    })();
+    return initPromise;
+}
+export function getModule() {
+    if (!module)
+        throw new Error("Module not initialized. Call initZstd() first.");
+    return module;
+}

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+export interface Module {
+    _createCCtx(): number;
+    _createDCtx(): number;
+    _freeCCtx(ctx: number): void;
+    _freeDCtx(ctx: number): void;
+    _initCStream(ctx: number, level: number): number;
+    _initDStream(ctx: number): number;
+    _compressStream(ctx: number, dst: number, dstSize: number, src: number, srcSize: number, end: number): number;
+    _decompressStream(ctx: number, dst: number, dstSize: number, src: number, srcSize: number): number;
+    _dStreamOutSize(): number;
+    _cStreamOutSize(): number;
+    _getErrorName(error: number): string;
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+    HEAPU8: Uint8Array;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "zstd-stream",
+  "version": "1.0.0",
+  "description": "Simple and efficient Zstandard compression/decompression for Node.js and browsers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsc",
+    "rebuild": "npm run clean && npm run build",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+    "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testPathIgnorePatterns=integration",
+    "test:integration": "node --experimental-vm-modules node_modules/jest/bin/jest.js integration.test.ts",
+    "prepare": "npm run build",
+    "prepack": "npm run clean && npm run build",
+    "prepublishOnly": "npm test",
+    "pack:check": "npm run prepack && npm pack --dry-run",
+    "publish:dry": "npm publish --dry-run"
+  },
+  "keywords": [
+    "zstd",
+    "zstandard",
+    "compression",
+    "decompression",
+    "wasm",
+    "stream",
+    "esm"
+  ],
+  "author": "Crellin Creative",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crellincreative/zstd-stream.git"
+  },
+  "bugs": {
+    "url": "https://github.com/crellincreative/zstd-stream/issues"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.3",
+    "jest": "^30.2.0",
+    "rimraf": "^6.1.2",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}