@addmaple/gzip 0.1.0

package/README.md

@@ -0,0 +1,52 @@
+# @addmaple/gzip
+
+Fast Gzip compression in the browser and Node.js using Rust + WASM.
+
+**3.5x-5.5x faster** than `pako`.
+
+## Installation
+
+```bash
+npm install @addmaple/gzip
+```
+
+## Usage
+
+```javascript
+import { init, compress } from '@addmaple/gzip';
+
+await init();
+
+const input = new TextEncoder().encode('hello world');
+const compressed = await compress(input, { level: 9 });
+```
+
+### Inline (Zero-latency)
+
+WASM bytes embedded directly in JS — no separate file fetching:
+
+```javascript
+import { init, compress } from '@addmaple/gzip/inline';
+
+await init();
+const compressed = await compress(input);
+```
+
+## API
+
+### `init()`
+Initialize the WASM module.
+
+### `compress(input, options?)`
+- `input`: `Uint8Array`
+- `options.level`: 1-9 (default: 6)
+- Returns: `Promise<Uint8Array>`
+
+## Sponsor
+
+Development of this module was sponsored by [addmaple.com](https://addmaple.com) — a modern data analysis platform.
+
+## License
+
+MIT
+

package/dist/browser-inline.d.ts

@@ -0,0 +1,2 @@
+export function init(imports?: WebAssembly.Imports): Promise<void>;
+export * from "./custom.js";

package/dist/browser-inline.js

@@ -0,0 +1,22 @@
+import { setInstance, registerInit } from "./core.js";
+import { instantiateWithFallback } 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";
+
+async function getWasmBytes() {
+  return { simdBytes, baseBytes };
+}
+
+
+let _ready = null;
+export function init(imports = {}) {
+  return (_ready ??= (async () => {
+    const { simdBytes, baseBytes } = await getWasmBytes();
+    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+    setInstance(instance);
+  })());
+}
+
+registerInit(init);
+export * from "./custom.js";

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export function init(imports?: WebAssembly.Imports): Promise<void>;
+export * from "./custom.js";

package/dist/browser.js

@@ -0,0 +1,24 @@
+import { setInstance, registerInit } from "./core.js";
+import { instantiateWithFallback } 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 };
+}
+
+
+let _ready = null;
+export function init(imports = {}) {
+  return (_ready ??= (async () => {
+    const { simdBytes, baseBytes } = await getWasmBytes();
+    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+    setInstance(instance);
+  })());
+}
+
+registerInit(init);
+export * from "./custom.js";

package/dist/core.d.ts

@@ -0,0 +1,11 @@
+export type WasmInput = Uint8Array | ArrayBufferView | ArrayBuffer;
+
+export function setInstance(instance: WebAssembly.Instance): void;
+export function wasmExports(): WebAssembly.Exports;
+export function memoryU8(): Uint8Array;
+export function alloc(len: number): number;
+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>;

package/dist/core.js

@@ -0,0 +1,125 @@
+let _inst = null;
+let _memU8 = null;
+let _initFn = null;
+
+function refreshViews() {
+  _memU8 = new Uint8Array(_inst.exports.memory.buffer);
+}
+
+export function setInstance(instance) {
+  _inst = instance;
+  refreshViews();
+}
+
+export function wasmExports() {
+  return _inst.exports;
+}
+
+let _ready = null;
+export function registerInit(fn) { _initFn = fn; }
+
+async function ensureReady() {
+  if (_ready) return _ready;
+  if (!_initFn) throw new Error("init not registered");
+  _ready = _initFn();
+  return _ready;
+}
+
+export function memoryU8() {
+  if (_memU8 && _memU8.buffer !== _inst.exports.memory.buffer) refreshViews();
+  return _memU8;
+}
+
+export function alloc(len) {
+  return _inst.exports.alloc_bytes(len) >>> 0;
+}
+
+export function free(ptr, len) {
+  _inst.exports.free_bytes(ptr >>> 0, len >>> 0);
+}
+
+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");
+}
+
+function callWasm(abi, input, outLen, reuse) {
+  if (!_inst) throw new Error("WASM instance not initialized");
+  const view = toBytes(input);
+  const len = view.byteLength;
+
+  let inPtr, outPtr;
+  if (reuse) {
+    if (reuse.in.len < len) {
+      if (reuse.in.ptr) free(reuse.in.ptr, reuse.in.len);
+      reuse.in.ptr = alloc(len);
+      reuse.in.len = len;
+    }
+    if (reuse.out.len < outLen) {
+      if (reuse.out.ptr) free(reuse.out.ptr, reuse.out.len);
+      reuse.out.ptr = alloc(outLen);
+      reuse.out.len = outLen;
+    }
+    inPtr = reuse.in.ptr;
+    outPtr = reuse.out.ptr;
+  } else {
+    inPtr = alloc(len);
+    outPtr = alloc(outLen);
+  }
+
+  memoryU8().set(view, inPtr);
+  const written = _inst.exports[abi](inPtr, len, outPtr, outLen);
+  if (written < 0) {
+    if (!reuse) { free(inPtr, len); free(outPtr, outLen); }
+    throw new Error(abi + " failed: " + written);
+  }
+
+  return { inPtr, outPtr, len, outLen, written };
+}
+
+async function compress_level_1(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len + 1024;
+  const { outPtr, written, inPtr } = callWasm("compress_gzip_level_1", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { compress_level_1 };
+
+async function compress_level_6(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len + 1024;
+  const { outPtr, written, inPtr } = callWasm("compress_gzip_level_6", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { compress_level_6 };
+
+async function compress_level_9(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len + 1024;
+  const { outPtr, written, inPtr } = callWasm("compress_gzip_level_9", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { compress_level_9 };

package/dist/custom.js

@@ -0,0 +1,15 @@
+import { compress_level_1, compress_level_6, compress_level_9, wasmExports } from './core.js';
+
+export async function compress(input, options = {}) {
+  const level = options.level ?? 6;
+  
+  try {
+    if (level <= 1) return compress_level_1(input);
+    if (level <= 6) return compress_level_6(input);
+    return compress_level_9(input);
+  } catch (error) {
+    throw new Error(`Compression failed: ${error.message}`);
+  }
+}
+
+export { wasmExports };

package/dist/node-inline.d.ts

@@ -0,0 +1,2 @@
+export function init(imports?: WebAssembly.Imports): Promise<void>;
+export * from "./custom.js";

package/dist/node-inline.js

@@ -0,0 +1,22 @@
+import { setInstance, registerInit } from "./core.js";
+import { instantiateWithFallback } 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";
+
+async function getWasmBytes() {
+  return { simdBytes, baseBytes };
+}
+
+
+let _ready = null;
+export function init(imports = {}) {
+  return (_ready ??= (async () => {
+    const { simdBytes, baseBytes } = await getWasmBytes();
+    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+    setInstance(instance);
+  })());
+}
+
+registerInit(init);
+export * from "./custom.js";

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+export function init(imports?: WebAssembly.Imports): Promise<void>;
+export * from "./custom.js";

package/dist/node.js

@@ -0,0 +1,29 @@
+import { setInstance, registerInit } from "./core.js";
+import { instantiateWithFallback } from "./util.js";
+
+import { readFile } from "node:fs/promises";
+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 };
+}
+
+
+let _ready = null;
+export function init(imports = {}) {
+  return (_ready ??= (async () => {
+    const { simdBytes, baseBytes } = await getWasmBytes();
+    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+    setInstance(instance);
+  })());
+}
+
+registerInit(init);
+export * from "./custom.js";

package/dist/util.js

@@ -0,0 +1,14 @@
+export async function instantiateWithFallback(
+  trySimdBytes,
+  baseBytes,
+  imports
+) {
+  try {
+    const { instance } = await WebAssembly.instantiate(trySimdBytes, imports)
+    return { instance, backend: 'wasm-simd' }
+  } catch {
+    // If SIMD fails (not supported), try baseline
+    const { instance } = await WebAssembly.instantiate(baseBytes, imports)
+    return { instance, backend: 'wasm' }
+  }
+}