@addmaple/gzip 0.1.0 → 0.1.1

package/dist/browser-inline.d.ts

@@ -1,2 +1,5 @@
-export function init(imports?: WebAssembly.Imports): Promise<void>;
+export interface InitOptions {
+  backend?: 'auto' | 'simd' | 'base';
+}
+export function init(imports?: WebAssembly.Imports, opts?: InitOptions): Promise<void>;
 export * from "./custom.js";

package/dist/browser-inline.js

@@ -1,19 +1,26 @@
 import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
+import { instantiateWithBackend } from "./util.js";
 
-import { wasmBytes as simdBytes } from "./wasm-inline/gzip.simd.wasm.js";
-import { wasmBytes as baseBytes } from "./wasm-inline/gzip.base.wasm.js";
+import { wasmBytes as _simdBytes } from "./wasm-inline/gzip.simd.wasm.js";
+import { wasmBytes as _baseBytes } from "./wasm-inline/gzip.base.wasm.js";
 
-async function getWasmBytes() {
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  return _simdBytes;
+}
+
+async function getBaseBytes() {
+  return _baseBytes;
 }
 
 
 let _ready = null;
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { simdBytes, baseBytes } = await getWasmBytes();
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+let _backend = null;
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto';
+  if (_ready && _backend === backend) return _ready;
+  _backend = backend;
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({ getSimdBytes, getBaseBytes, imports, backend });
     setInstance(instance);
   })());
 }

package/dist/browser.d.ts

@@ -1,2 +1,5 @@
-export function init(imports?: WebAssembly.Imports): Promise<void>;
+export interface InitOptions {
+  backend?: 'auto' | 'simd' | 'base';
+}
+export function init(imports?: WebAssembly.Imports, opts?: InitOptions): Promise<void>;
 export * from "./custom.js";

package/dist/browser.js

@@ -1,21 +1,28 @@
 import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
+import { instantiateWithBackend } from "./util.js";
 
 const simdUrl = new URL("./wasm/gzip.simd.wasm", import.meta.url);
 const baseUrl = new URL("./wasm/gzip.base.wasm", import.meta.url);
 
-async function getWasmBytes() {
-  const [simdRes, baseRes] = await Promise.all([fetch(simdUrl), fetch(baseUrl)]);
-  const [simdBytes, baseBytes] = await Promise.all([simdRes.arrayBuffer(), baseRes.arrayBuffer()]);
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  const res = await fetch(simdUrl);
+  return res.arrayBuffer();
+}
+
+async function getBaseBytes() {
+  const res = await fetch(baseUrl);
+  return res.arrayBuffer();
 }
 
 
 let _ready = null;
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { simdBytes, baseBytes } = await getWasmBytes();
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+let _backend = null;
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto';
+  if (_ready && _backend === backend) return _ready;
+  _backend = backend;
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({ getSimdBytes, getBaseBytes, imports, backend });
     setInstance(instance);
   })());
 }

package/dist/core.d.ts

@@ -8,4 +8,8 @@ export function free(ptr: number, len: number): void;
 
 export function compress_level_1(input: WasmInput): Promise<Uint8Array>;
 export function compress_level_6(input: WasmInput): Promise<Uint8Array>;
-export function compress_level_9(input: WasmInput): Promise<Uint8Array>;
+export function compress_level_9(input: WasmInput): Promise<Uint8Array>;
+export function decompress_gzip(input: WasmInput): Promise<Uint8Array>;
+export function create_gzip_compressor(input: WasmInput): Promise<number>;
+export function compress_gzip_chunk(input: WasmInput): Promise<Uint8Array>;
+export function destroy_gzip_compressor(input: WasmInput): Promise<Uint8Array>;

package/dist/core.js

@@ -45,6 +45,40 @@ function toBytes(input) {
   throw new TypeError("Expected a TypedArray or ArrayBuffer");
 }
 
+function scalarSize(type) {
+  switch (type) {
+    case "f64": return 8;
+    case "f32":
+    case "i32":
+    case "u32": return 4;
+    case "i16":
+    case "u16": return 2;
+    case "i8":
+    case "u8": return 1;
+    case "u32_array":
+    case "i32_array":
+    case "f32_array": return 1024 * 1024;
+    default: return 0;
+  }
+}
+
+function decodeReturn(view, type) {
+  switch (type) {
+    case "f32": return view.getFloat32(0, true);
+    case "f64": return view.getFloat64(0, true);
+    case "i32": return view.getInt32(0, true);
+    case "u32": return view.getUint32(0, true);
+    case "i16": return view.getInt16(0, true);
+    case "u16": return view.getUint16(0, true);
+    case "i8": return view.getInt8(0);
+    case "u8": return view.getUint8(0);
+    case "u32_array": return new Uint32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    case "i32_array": return new Int32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    case "f32_array": return new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    default: return null;
+  }
+}
+
 function callWasm(abi, input, outLen, reuse) {
   if (!_inst) throw new Error("WASM instance not initialized");
   const view = toBytes(input);
@@ -123,3 +157,64 @@ async function compress_level_9(input) {
   return result;
 }
 export { compress_level_9 };
+
+async function decompress_gzip(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len * 10;
+  const { outPtr, written, inPtr } = callWasm("decompress_gzip", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { decompress_gzip };
+
+async function create_gzip_compressor(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = (scalarSize('u32') || 4);
+  const { outPtr, written, inPtr } = callWasm("create_gzip_compressor", view, outLen, null);
+
+  const retView = new DataView(memoryU8().buffer, outPtr, written);
+  const result = decodeReturn(retView, "u32");
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { create_gzip_compressor };
+
+async function compress_gzip_chunk(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len + 1024;
+  const { outPtr, written, inPtr } = callWasm("compress_gzip_chunk", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { compress_gzip_chunk };
+
+async function destroy_gzip_compressor(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = Math.max(len, 4);
+  const { outPtr, written, inPtr } = callWasm("destroy_gzip_compressor", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { destroy_gzip_compressor };

package/dist/custom.js

@@ -1,4 +1,28 @@
-import { compress_level_1, compress_level_6, compress_level_9, wasmExports } from './core.js';
+import { 
+  compress_level_1, 
+  compress_level_6, 
+  compress_level_9,
+  decompress_gzip,
+  create_gzip_compressor,
+  compress_gzip_chunk,
+  destroy_gzip_compressor,
+  wasmExports,
+  alloc,
+  free,
+  memoryU8,
+  ensureReady
+} from './core.js';
+
+function toBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  throw new TypeError("Expected a TypedArray or ArrayBuffer");
+}
+
+// ============================================================================
+// One-shot Compression API
+// ============================================================================
 
 export async function compress(input, options = {}) {
   const level = options.level ?? 6;
@@ -12,4 +36,139 @@ export async function compress(input, options = {}) {
   }
 }
 
+// ============================================================================
+// One-shot Decompression API
+// ============================================================================
+
+export async function decompress(input) {
+  await ensureReady();
+  
+  const view = toBytes(input);
+  const len = view.byteLength;
+  
+  // Start with a reasonable estimate (10x compressed size)
+  let outLen = Math.max(len * 10, 65536);
+  
+  const inPtr = alloc(len);
+  let outPtr = alloc(outLen);
+  
+  try {
+    memoryU8().set(view, inPtr);
+    let written = wasmExports().decompress_gzip(inPtr, len, outPtr, outLen);
+    
+    // Negative value means we need more space
+    if (written < 0) {
+      const neededLen = -written;
+      free(outPtr, outLen);
+      outLen = neededLen;
+      outPtr = alloc(outLen);
+      
+      // Retry with correct size
+      written = wasmExports().decompress_gzip(inPtr, len, outPtr, outLen);
+      
+      if (written < 0) {
+        throw new Error('Decompression failed after resize');
+      }
+    }
+    
+    const result = memoryU8().slice(outPtr, outPtr + written);
+    free(inPtr, len);
+    free(outPtr, outLen);
+    return result;
+  } catch (error) {
+    free(inPtr, len);
+    free(outPtr, outLen);
+    throw new Error(`Decompression failed: ${error.message}`);
+  }
+}
+
+// ============================================================================
+// Streaming Compression API
+// ============================================================================
+
+export class StreamingCompressor {
+  constructor(options = {}) {
+    this._initPromise = ensureReady();
+    this.level = options.level ?? 6;
+    this.handle = null;
+  }
+
+  async _ensureInit() {
+    await this._initPromise;
+    if (this.handle === null) {
+      this.handle = wasmExports().create_gzip_compressor(this.level);
+      if (this.handle === 0) {
+        throw new Error('Failed to create compressor');
+      }
+    }
+  }
+
+  async compressChunk(input, finish = false) {
+    await this._ensureInit();
+    if (this.handle === 0) {
+      throw new Error('Compressor already destroyed');
+    }
+    
+    const view = toBytes(input);
+    const len = view.byteLength;
+    const outLen = len + 1024;
+    
+    const inPtr = alloc(len);
+    const outPtr = alloc(outLen);
+    
+    try {
+      memoryU8().set(view, inPtr);
+      const written = wasmExports().compress_gzip_chunk(this.handle, inPtr, len, outPtr, outLen, finish ? 1 : 0);
+      
+      if (written < 0) {
+        if (written === -1) {
+          throw new Error('Compression failed');
+        } else {
+          // Negative value indicates needed buffer size
+          free(outPtr, outLen);
+          const neededLen = -written;
+          const newOutPtr = alloc(neededLen);
+          memoryU8().set(view, inPtr);
+          const retryWritten = wasmExports().compress_gzip_chunk(this.handle, inPtr, len, newOutPtr, neededLen, finish ? 1 : 0);
+          if (retryWritten < 0) {
+            free(newOutPtr, neededLen);
+            throw new Error('Compression failed after retry');
+          }
+          const result = memoryU8().slice(newOutPtr, newOutPtr + retryWritten);
+          free(newOutPtr, neededLen);
+          free(inPtr, len);
+          if (finish) this.handle = 0;
+          return result;
+        }
+      }
+      
+      if (written === 0) {
+        free(outPtr, outLen);
+        free(inPtr, len);
+        return new Uint8Array(0);
+      }
+      
+      const result = memoryU8().slice(outPtr, outPtr + written);
+      free(outPtr, outLen);
+      free(inPtr, len);
+      
+      if (finish) this.handle = 0;
+      return result;
+    } catch (error) {
+      free(outPtr, outLen);
+      free(inPtr, len);
+      throw new Error(`Compression failed: ${error.message}`);
+    }
+  }
+
+  async destroy() {
+    await this._initPromise;
+    if (this.handle !== 0 && this.handle !== null) {
+      wasmExports().destroy_gzip_compressor(this.handle);
+      this.handle = 0;
+    }
+  }
+}
+
 export { wasmExports };
+

package/dist/node-inline.d.ts

@@ -1,2 +1,5 @@
-export function init(imports?: WebAssembly.Imports): Promise<void>;
+export interface InitOptions {
+  backend?: 'auto' | 'simd' | 'base';
+}
+export function init(imports?: WebAssembly.Imports, opts?: InitOptions): Promise<void>;
 export * from "./custom.js";

package/dist/node-inline.js

@@ -1,19 +1,26 @@
 import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
+import { instantiateWithBackend } from "./util.js";
 
-import { wasmBytes as simdBytes } from "./wasm-inline/gzip.simd.wasm.js";
-import { wasmBytes as baseBytes } from "./wasm-inline/gzip.base.wasm.js";
+import { wasmBytes as _simdBytes } from "./wasm-inline/gzip.simd.wasm.js";
+import { wasmBytes as _baseBytes } from "./wasm-inline/gzip.base.wasm.js";
 
-async function getWasmBytes() {
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  return _simdBytes;
+}
+
+async function getBaseBytes() {
+  return _baseBytes;
 }
 
 
 let _ready = null;
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { simdBytes, baseBytes } = await getWasmBytes();
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+let _backend = null;
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto';
+  if (_ready && _backend === backend) return _ready;
+  _backend = backend;
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({ getSimdBytes, getBaseBytes, imports, backend });
     setInstance(instance);
   })());
 }

package/dist/node.d.ts

@@ -1,2 +1,5 @@
-export function init(imports?: WebAssembly.Imports): Promise<void>;
+export interface InitOptions {
+  backend?: 'auto' | 'simd' | 'base';
+}
+export function init(imports?: WebAssembly.Imports, opts?: InitOptions): Promise<void>;
 export * from "./custom.js";

package/dist/node.js

@@ -1,5 +1,5 @@
 import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
+import { instantiateWithBackend } from "./util.js";
 
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
@@ -7,20 +7,23 @@ import { fileURLToPath } from "node:url";
 const simdPath = fileURLToPath(new URL("./wasm/gzip.simd.wasm", import.meta.url));
 const basePath = fileURLToPath(new URL("./wasm/gzip.base.wasm", import.meta.url));
 
-async function getWasmBytes() {
-  const [simdBytes, baseBytes] = await Promise.all([
-    readFile(simdPath).catch(() => null),
-    readFile(basePath).catch(() => null)
-  ]);
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  return readFile(simdPath);
+}
+
+async function getBaseBytes() {
+  return readFile(basePath);
 }
 
 
 let _ready = null;
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { simdBytes, baseBytes } = await getWasmBytes();
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+let _backend = null;
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto';
+  if (_ready && _backend === backend) return _ready;
+  _backend = backend;
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({ getSimdBytes, getBaseBytes, imports, backend });
     setInstance(instance);
   })());
 }

package/dist/util.js

@@ -12,3 +12,33 @@ export async function instantiateWithFallback(
     return { instance, backend: 'wasm' }
   }
 }
+
+export async function instantiateWithBackend({
+  getSimdBytes,
+  getBaseBytes,
+  imports,
+  backend = 'auto',
+}) {
+  if (backend === 'base') {
+    const baseBytes = await getBaseBytes()
+    const { instance } = await WebAssembly.instantiate(baseBytes, imports)
+    return { instance, backend: 'wasm' }
+  }
+
+  if (backend === 'simd') {
+    const simdBytes = await getSimdBytes()
+    const { instance } = await WebAssembly.instantiate(simdBytes, imports)
+    return { instance, backend: 'wasm-simd' }
+  }
+
+  // auto: try simd first, then fallback to baseline
+  try {
+    const simdBytes = await getSimdBytes()
+    const { instance } = await WebAssembly.instantiate(simdBytes, imports)
+    return { instance, backend: 'wasm-simd' }
+  } catch {
+    const baseBytes = await getBaseBytes()
+    const { instance } = await WebAssembly.instantiate(baseBytes, imports)
+    return { instance, backend: 'wasm' }
+  }
+}