@icure/lzma-wasm 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Taktik sa - B12 Consulting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The compiled WebAssembly module (dist/lzma.wasm) includes liblzma from
+XZ Utils 5.6.4, which is licensed under the BSD Zero Clause License (0BSD).
+See LICENSE.liblzma.

package/LICENSE.liblzma

@@ -0,0 +1,11 @@
+Permission to use, copy, modify, and/or distribute this
+software for any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,3 +1,44 @@
-# Temporary Holding Version
+# @icure/lzma-wasm
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+LZMA2 / XZ compression and decompression for browsers, web workers and Node.js, using
+[liblzma](https://tukaani.org/xz/) (XZ Utils 5.6.4) compiled to WebAssembly with Emscripten.
+
+Output is a standard `.xz` stream (LZMA2 filter, CRC64 check) that interoperates with the `xz` CLI.
+
+## Install
+
+```bash
+npm install @icure/lzma-wasm
+```
+
+## Usage
+
+```ts
+import { lzmaWasmCompress, lzmaWasmDecompress } from '@icure/lzma-wasm'
+
+const compressed: ArrayBuffer = await lzmaWasmCompress(new TextEncoder().encode('hello'), 6) // preset 0-9, default 6
+const decompressed: ArrayBuffer = await lzmaWasmDecompress(compressed)
+```
+
+Both functions accept an `ArrayBuffer` or a `Uint8Array` and never modify their input.
+The WASM module is loaded lazily on first call. `getLzmaModule()` gives access to the raw Emscripten module.
+
+### Bundlers
+
+`dist/lzma.js` locates `lzma.wasm` next to itself. When bundling for the browser, make sure
+`lzma.wasm` is emitted as an asset alongside the bundled glue code (e.g. webpack `asset/resource`,
+or copy it to your public directory).
+
+## Rebuilding the WASM module
+
+The prebuilt `src/lzma.js` and `src/lzma.wasm` are committed. To rebuild them you need
+[Emscripten](https://emscripten.org/) (`emcc`) on your `PATH`:
+
+```bash
+npm run build:wasm   # downloads xz 5.6.4 into src/build, compiles src/lzma_wasm.c + liblzma
+npm test
+```
+
+## License
+
+MIT for the code in this repository. liblzma is 0BSD (see `LICENSE.liblzma`).

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * WASM-based LZMA2/XZ compression using liblzma compiled via Emscripten.
+ * The WASM module is lazy-loaded on first use.
+ */
+import type { LzmaWasmModule } from './lzma.js';
+export type { LzmaWasmModule };
+/**
+ * Returns the (lazily instantiated) raw Emscripten module, for advanced use.
+ */
+export declare function getLzmaModule(): Promise<LzmaWasmModule>;
+/**
+ * Compresses data into the .xz container format (LZMA2 filter, CRC64 check).
+ * @param data the data to compress
+ * @param preset the xz preset level (0-9), defaults to 6
+ */
+export declare function lzmaWasmCompress(data: ArrayBuffer | Uint8Array, preset?: number): Promise<ArrayBuffer>;
+/**
+ * Decompresses data in the .xz container format.
+ * @param data the compressed data
+ */
+export declare function lzmaWasmDecompress(data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;

package/dist/index.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * WASM-based LZMA2/XZ compression using liblzma compiled via Emscripten.
+ * The WASM module is lazy-loaded on first use.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLzmaModule = getLzmaModule;
+exports.lzmaWasmCompress = lzmaWasmCompress;
+exports.lzmaWasmDecompress = lzmaWasmDecompress;
+let modulePromise = null;
+/**
+ * Returns the (lazily instantiated) raw Emscripten module, for advanced use.
+ */
+function getLzmaModule() {
+    if (!modulePromise) {
+        modulePromise = (async () => {
+            // Dynamic import of the Emscripten glue code
+            const factory = (await Promise.resolve().then(() => require('./lzma.js'))).default;
+            return factory();
+        })();
+    }
+    return modulePromise;
+}
+function run(mod, input, op, call) {
+    const inputPtr = mod._malloc(input.length);
+    if (!inputPtr)
+        throw new Error('WASM malloc failed for input');
+    try {
+        mod.HEAPU8.set(input, inputPtr);
+        const ret = call(inputPtr, input.length);
+        if (ret !== 0) {
+            mod._free_result();
+            throw new Error(`LZMA WASM ${op} failed with code ${ret}`);
+        }
+        const resultPtr = mod._get_result_ptr();
+        const resultLen = mod._get_result_len();
+        const output = new Uint8Array(resultLen);
+        output.set(mod.HEAPU8.subarray(resultPtr, resultPtr + resultLen));
+        mod._free_result();
+        return output.buffer;
+    }
+    finally {
+        mod._free(inputPtr);
+    }
+}
+/**
+ * Compresses data into the .xz container format (LZMA2 filter, CRC64 check).
+ * @param data the data to compress
+ * @param preset the xz preset level (0-9), defaults to 6
+ */
+async function lzmaWasmCompress(data, preset = 6) {
+    const mod = await getLzmaModule();
+    const input = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    return run(mod, input, 'compress', (ptr, len) => mod._lzma_wasm_compress(ptr, len, preset));
+}
+/**
+ * Decompresses data in the .xz container format.
+ * @param data the compressed data
+ */
+async function lzmaWasmDecompress(data) {
+    const mod = await getLzmaModule();
+    const input = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    return run(mod, input, 'decompress', (ptr, len) => mod._lzma_wasm_decompress(ptr, len));
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAWH,sCASC;AA8BD,4CAIC;AAMD,gDAIC;AA1DD,IAAI,aAAa,GAAmC,IAAI,CAAA;AAExD;;GAEG;AACH,SAAgB,aAAa;IAC3B,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,aAAa,GAAG,CAAC,KAAK,IAAI,EAAE;YAC1B,6CAA6C;YAC7C,MAAM,OAAO,GAAkC,CAAC,2CAAa,WAAW,EAAC,CAAC,CAAC,OAAO,CAAA;YAClF,OAAO,OAAO,EAAE,CAAA;QAClB,CAAC,CAAC,EAAE,CAAA;IACN,CAAC;IACD,OAAO,aAAa,CAAA;AACtB,CAAC;AAED,SAAS,GAAG,CAAC,GAAmB,EAAE,KAAiB,EAAE,EAA6B,EAAE,IAA0C;IAC5H,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC1C,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAA;IAE9D,IAAI,CAAC;QACH,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACxC,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;YACd,GAAG,CAAC,YAAY,EAAE,CAAA;YAClB,MAAM,IAAI,KAAK,CAAC,aAAa,EAAE,qBAAqB,GAAG,EAAE,CAAC,CAAA;QAC5D,CAAC;QAED,MAAM,SAAS,GAAG,GAAG,CAAC,eAAe,EAAE,CAAA;QACvC,MAAM,SAAS,GAAG,GAAG,CAAC,eAAe,EAAE,CAAA;QACvC,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,CAAA;QACxC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC,CAAC,CAAA;QACjE,GAAG,CAAC,YAAY,EAAE,CAAA;QAClB,OAAO,MAAM,CAAC,MAAM,CAAA;IACtB,CAAC;YAAS,CAAC;QACT,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IACrB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,IAA8B,EAAE,SAAiB,CAAC;IACvF,MAAM,GAAG,GAAG,MAAM,aAAa,EAAE,CAAA;IACjC,MAAM,KAAK,GAAG,IAAI,YAAY,WAAW,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IACvE,OAAO,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;AAC7F,CAAC;AAED;;;GAGG;AACI,KAAK,UAAU,kBAAkB,CAAC,IAA8B;IACrE,MAAM,GAAG,GAAG,MAAM,aAAa,EAAE,CAAA;IACjC,MAAM,KAAK,GAAG,IAAI,YAAY,WAAW,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IACvE,OAAO,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;AACzF,CAAC","sourcesContent":["/**\n * WASM-based LZMA2/XZ compression using liblzma compiled via Emscripten.\n * The WASM module is lazy-loaded on first use.\n */\n\nimport type { LzmaWasmModule } from './lzma.js'\n\nexport type { LzmaWasmModule }\n\nlet modulePromise: Promise<LzmaWasmModule> | null = null\n\n/**\n * Returns the (lazily instantiated) raw Emscripten module, for advanced use.\n */\nexport function getLzmaModule(): Promise<LzmaWasmModule> {\n  if (!modulePromise) {\n    modulePromise = (async () => {\n      // Dynamic import of the Emscripten glue code\n      const factory: () => Promise<LzmaWasmModule> = (await import('./lzma.js')).default\n      return factory()\n    })()\n  }\n  return modulePromise\n}\n\nfunction run(mod: LzmaWasmModule, input: Uint8Array, op: 'compress' | 'decompress', call: (ptr: number, len: number) => number): ArrayBuffer {\n  const inputPtr = mod._malloc(input.length)\n  if (!inputPtr) throw new Error('WASM malloc failed for input')\n\n  try {\n    mod.HEAPU8.set(input, inputPtr)\n    const ret = call(inputPtr, input.length)\n    if (ret !== 0) {\n      mod._free_result()\n      throw new Error(`LZMA WASM ${op} failed with code ${ret}`)\n    }\n\n    const resultPtr = mod._get_result_ptr()\n    const resultLen = mod._get_result_len()\n    const output = new Uint8Array(resultLen)\n    output.set(mod.HEAPU8.subarray(resultPtr, resultPtr + resultLen))\n    mod._free_result()\n    return output.buffer\n  } finally {\n    mod._free(inputPtr)\n  }\n}\n\n/**\n * Compresses data into the .xz container format (LZMA2 filter, CRC64 check).\n * @param data the data to compress\n * @param preset the xz preset level (0-9), defaults to 6\n */\nexport async function lzmaWasmCompress(data: ArrayBuffer | Uint8Array, preset: number = 6): Promise<ArrayBuffer> {\n  const mod = await getLzmaModule()\n  const input = data instanceof ArrayBuffer ? new Uint8Array(data) : data\n  return run(mod, input, 'compress', (ptr, len) => mod._lzma_wasm_compress(ptr, len, preset))\n}\n\n/**\n * Decompresses data in the .xz container format.\n * @param data the compressed data\n */\nexport async function lzmaWasmDecompress(data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer> {\n  const mod = await getLzmaModule()\n  const input = data instanceof ArrayBuffer ? new Uint8Array(data) : data\n  return run(mod, input, 'decompress', (ptr, len) => mod._lzma_wasm_decompress(ptr, len))\n}\n"]}

package/dist/lzma.d.ts

@@ -0,0 +1,13 @@
+export interface LzmaWasmModule {
+  _lzma_wasm_compress(ptr: number, len: number, preset: number): number
+  _lzma_wasm_decompress(ptr: number, len: number): number
+  _get_result_ptr(): number
+  _get_result_len(): number
+  _free_result(): void
+  _malloc(size: number): number
+  _free(ptr: number): void
+  HEAPU8: Uint8Array
+}
+
+declare function createLzmaModule(): Promise<LzmaWasmModule>
+export default createLzmaModule

package/dist/lzma.js

@@ -0,0 +1,507 @@
+var createLzmaModule = (() => {
+  var _scriptName = globalThis.document?.currentScript?.src;
+  return async function (moduleArg = {}) {
+    var moduleRtn;
+    var Module = moduleArg;
+    var ENVIRONMENT_IS_WEB = !!globalThis.window;
+    var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+    var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+    var arguments_ = [];
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow
+    };
+    if (typeof __filename != "undefined") {
+      _scriptName = __filename
+    } else if (ENVIRONMENT_IS_WORKER) {
+      _scriptName = self.location.href
+    }
+    var scriptDirectory = "";
+
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory)
+      }
+      return scriptDirectory + path
+    }
+
+    var readAsync, readBinary;
+    if (ENVIRONMENT_IS_NODE) {
+      // Aliased require so bundlers (esbuild/webpack on Vercel, Next.js, ...) don't try to
+      // statically resolve the Node-only "node:fs" builtin when bundling for the browser/edge.
+      // This branch only runs under Node, where `require` is available.
+      var nodeRequire = typeof require === "function" ? require : undefined;
+      var fs = nodeRequire("node:fs");
+      scriptDirectory = __dirname + "/";
+      readBinary = filename => {
+        filename = isFileURI(filename) ? new URL(filename) : filename;
+        var ret = fs.readFileSync(filename);
+        return ret
+      };
+      readAsync = async (filename, binary = true) => {
+        filename = isFileURI(filename) ? new URL(filename) : filename;
+        var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
+        return ret
+      };
+      if (process.argv.length > 1) {
+        thisProgram = process.argv[1].replace(/\\/g, "/")
+      }
+      arguments_ = process.argv.slice(2);
+      quit_ = (status, toThrow) => {
+        process.exitCode = status;
+        throw toThrow
+      }
+    } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+      try {
+        scriptDirectory = new URL(".", _scriptName).href
+      } catch {
+      }
+      {
+        if (ENVIRONMENT_IS_WORKER) {
+          readBinary = url => {
+            var xhr = new XMLHttpRequest;
+            xhr.open("GET", url, false);
+            xhr.responseType = "arraybuffer";
+            xhr.send(null);
+            return new Uint8Array(xhr.response)
+          }
+        }
+        readAsync = async url => {
+          var response = await fetch(url, {credentials: "same-origin"});
+          if (response.ok) {
+            return response.arrayBuffer()
+          }
+          throw new Error(response.status + " : " + response.url)
+        }
+      }
+    } else {
+    }
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    var wasmBinary;
+    var ABORT = false;
+    var isFileURI = filename => filename.startsWith("file://");
+    var readyPromiseResolve, readyPromiseReject;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+    var HEAP64, HEAPU64;
+    var runtimeInitialized = false;
+
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      HEAP32 = new Int32Array(b);
+      HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b)
+    }
+
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift())
+        }
+      }
+      callRuntimeCallbacks(onPreRuns)
+    }
+
+    function initRuntime() {
+      runtimeInitialized = true;
+      wasmExports["c"]()
+    }
+
+    function postRun() {
+      if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+        while (Module["postRun"].length) {
+          addOnPostRun(Module["postRun"].shift())
+        }
+      }
+      callRuntimeCallbacks(onPostRuns)
+    }
+
+    function abort(what) {
+      Module["onAbort"]?.(what);
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject?.(e);
+      throw e
+    }
+
+    var wasmBinaryFile;
+
+    function findWasmBinary() {
+      return locateFile("lzma.wasm")
+    }
+
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary)
+      }
+      if (readBinary) {
+        return readBinary(file)
+      }
+      throw "both async and sync fetching of the wasm failed"
+    }
+
+    async function getWasmBinary(binaryFile) {
+      if (!wasmBinary) {
+        try {
+          var response = await readAsync(binaryFile);
+          return new Uint8Array(response)
+        } catch {
+        }
+      }
+      return getBinarySync(binaryFile)
+    }
+
+    async function instantiateArrayBuffer(binaryFile, imports) {
+      try {
+        var binary = await getWasmBinary(binaryFile);
+        var instance = await WebAssembly.instantiate(binary, imports);
+        return instance
+      } catch (reason) {
+        err(`failed to asynchronously prepare wasm: ${reason}`);
+        abort(reason)
+      }
+    }
+
+    async function instantiateAsync(binary, binaryFile, imports) {
+      if (!binary && !ENVIRONMENT_IS_NODE) {
+        try {
+          var response = fetch(binaryFile, {credentials: "same-origin"});
+          var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+          return instantiationResult
+        } catch (reason) {
+          err(`wasm streaming compile failed: ${reason}`);
+          err("falling back to ArrayBuffer instantiation")
+        }
+      }
+      return instantiateArrayBuffer(binaryFile, imports)
+    }
+
+    function getWasmImports() {
+      var imports = {a: wasmImports};
+      return imports
+    }
+
+    async function createWasm() {
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        assignWasmExports(wasmExports);
+        updateMemoryViews();
+        return wasmExports
+      }
+
+      function receiveInstantiationResult(result) {
+        return receiveInstance(result["instance"])
+      }
+
+      var info = getWasmImports();
+      if (Module["instantiateWasm"]) {
+        return new Promise((resolve, reject) => {
+          Module["instantiateWasm"](info, (inst, mod) => {
+            resolve(receiveInstance(inst, mod))
+          })
+        })
+      }
+      wasmBinaryFile ??= findWasmBinary();
+      var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+      var exports = receiveInstantiationResult(result);
+      return exports
+    }
+
+    class ExitStatus {
+      name = "ExitStatus";
+
+      constructor(status) {
+        this.message = `Program terminated with exit(${status})`;
+        this.status = status
+      }
+    }
+
+    var callRuntimeCallbacks = callbacks => {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module)
+      }
+    };
+    var onPostRuns = [];
+    var addOnPostRun = cb => onPostRuns.push(cb);
+    var onPreRuns = [];
+    var addOnPreRun = cb => onPreRuns.push(cb);
+    var noExitRuntime = true;
+    var stackRestore = val => __emscripten_stack_restore(val);
+    var stackSave = () => _emscripten_stack_get_current();
+    var getHeapMax = () => 2147483648;
+    var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+    var growMemory = size => {
+      var oldHeapSize = wasmMemory.buffer.byteLength;
+      var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+      try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1
+      } catch (e) {
+      }
+    };
+    var _emscripten_resize_heap = requestedSize => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false
+      }
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true
+        }
+      }
+      return false
+    };
+    var getCFunc = ident => {
+      var func = Module["_" + ident];
+      return func
+    };
+    var writeArrayToMemory = (array, buffer) => {
+      HEAP8.set(array, buffer)
+    };
+    var lengthBytesUTF8 = str => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        var c = str.charCodeAt(i);
+        if (c <= 127) {
+          len++
+        } else if (c <= 2047) {
+          len += 2
+        } else if (c >= 55296 && c <= 57343) {
+          len += 4;
+          ++i
+        } else {
+          len += 3
+        }
+      }
+      return len
+    };
+    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+      if (!(maxBytesToWrite > 0)) return 0;
+      var startIdx = outIdx;
+      var endIdx = outIdx + maxBytesToWrite - 1;
+      for (var i = 0; i < str.length; ++i) {
+        var u = str.codePointAt(i);
+        if (u <= 127) {
+          if (outIdx >= endIdx) break;
+          heap[outIdx++] = u
+        } else if (u <= 2047) {
+          if (outIdx + 1 >= endIdx) break;
+          heap[outIdx++] = 192 | u >> 6;
+          heap[outIdx++] = 128 | u & 63
+        } else if (u <= 65535) {
+          if (outIdx + 2 >= endIdx) break;
+          heap[outIdx++] = 224 | u >> 12;
+          heap[outIdx++] = 128 | u >> 6 & 63;
+          heap[outIdx++] = 128 | u & 63
+        } else {
+          if (outIdx + 3 >= endIdx) break;
+          heap[outIdx++] = 240 | u >> 18;
+          heap[outIdx++] = 128 | u >> 12 & 63;
+          heap[outIdx++] = 128 | u >> 6 & 63;
+          heap[outIdx++] = 128 | u & 63;
+          i++
+        }
+      }
+      heap[outIdx] = 0;
+      return outIdx - startIdx
+    };
+    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    var stackAlloc = sz => __emscripten_stack_alloc(sz);
+    var stringToUTF8OnStack = str => {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret
+    };
+    var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
+    var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+      var maxIdx = idx + maxBytesToRead;
+      if (ignoreNul) return maxIdx;
+      while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+      return idx
+    };
+    var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+      var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr))
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode((u0 & 31) << 6 | u1);
+          continue
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = (u0 & 15) << 12 | u1 << 6 | u2
+        } else {
+          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63
+        }
+        if (u0 < 65536) {
+          str += String.fromCharCode(u0)
+        } else {
+          var ch = u0 - 65536;
+          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
+        }
+      }
+      return str
+    };
+    var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+    var ccall = (ident, returnType, argTypes, args, opts) => {
+      var toC = {
+        string: str => {
+          var ret = 0;
+          if (str !== null && str !== undefined && str !== 0) {
+            ret = stringToUTF8OnStack(str)
+          }
+          return ret
+        }, array: arr => {
+          var ret = stackAlloc(arr.length);
+          writeArrayToMemory(arr, ret);
+          return ret
+        }
+      };
+
+      function convertReturnValue(ret) {
+        if (returnType === "string") {
+          return UTF8ToString(ret)
+        }
+        if (returnType === "boolean") return Boolean(ret);
+        return ret
+      }
+
+      var func = getCFunc(ident);
+      var cArgs = [];
+      var stack = 0;
+      if (args) {
+        for (var i = 0; i < args.length; i++) {
+          var converter = toC[argTypes[i]];
+          if (converter) {
+            if (stack === 0) stack = stackSave();
+            cArgs[i] = converter(args[i])
+          } else {
+            cArgs[i] = args[i]
+          }
+        }
+      }
+      var ret = func(...cArgs);
+
+      function onDone(ret) {
+        if (stack !== 0) stackRestore(stack);
+        return convertReturnValue(ret)
+      }
+
+      ret = onDone(ret);
+      return ret
+    };
+    var cwrap = (ident, returnType, argTypes, opts) => {
+      var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean");
+      var numericRet = returnType !== "string";
+      if (numericRet && numericArgs && !opts) {
+        return getCFunc(ident)
+      }
+      return (...args) => ccall(ident, returnType, argTypes, args, opts)
+    };
+    {
+      if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+      if (Module["print"]) out = Module["print"];
+      if (Module["printErr"]) err = Module["printErr"];
+      if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+      if (Module["arguments"]) arguments_ = Module["arguments"];
+      if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+      if (Module["preInit"]) {
+        if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+        while (Module["preInit"].length > 0) {
+          Module["preInit"].shift()()
+        }
+      }
+    }
+    Module["ccall"] = ccall;
+    Module["cwrap"] = cwrap;
+    var _get_result_len, _get_result_ptr, _free_result, _free, _lzma_wasm_compress, _malloc, _lzma_wasm_decompress, __emscripten_stack_restore,
+      __emscripten_stack_alloc, _emscripten_stack_get_current, memory, __indirect_function_table, wasmMemory;
+
+    function assignWasmExports(wasmExports) {
+      _get_result_len = Module["_get_result_len"] = wasmExports["d"];
+      _get_result_ptr = Module["_get_result_ptr"] = wasmExports["e"];
+      _free_result = Module["_free_result"] = wasmExports["f"];
+      _free = Module["_free"] = wasmExports["g"];
+      _lzma_wasm_compress = Module["_lzma_wasm_compress"] = wasmExports["h"];
+      _malloc = Module["_malloc"] = wasmExports["i"];
+      _lzma_wasm_decompress = Module["_lzma_wasm_decompress"] = wasmExports["j"];
+      __emscripten_stack_restore = wasmExports["k"];
+      __emscripten_stack_alloc = wasmExports["l"];
+      _emscripten_stack_get_current = wasmExports["m"];
+      memory = wasmMemory = wasmExports["b"];
+      __indirect_function_table = wasmExports["__indirect_function_table"]
+    }
+
+    var wasmImports = {a: _emscripten_resize_heap};
+
+    function run() {
+      preRun();
+
+      function doRun() {
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        readyPromiseResolve?.(Module);
+        Module["onRuntimeInitialized"]?.();
+        postRun()
+      }
+
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+          setTimeout(() => Module["setStatus"](""), 1);
+          doRun()
+        }, 1)
+      } else {
+        doRun()
+      }
+    }
+
+    var wasmExports;
+    wasmExports = await (createWasm());
+    run();
+    if (runtimeInitialized) {
+      moduleRtn = Module
+    } else {
+      moduleRtn = new Promise((resolve, reject) => {
+        readyPromiseResolve = resolve;
+        readyPromiseReject = reject
+      })
+    }
+    ;
+    return moduleRtn
+  }
+})();
+if (typeof exports === "object" && typeof module === "object") {
+  module.exports = createLzmaModule;
+  module.exports.default = createLzmaModule
+} else if (typeof define === "function" && define["amd"]) define([], () => createLzmaModule);

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@icure/lzma-wasm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "LZMA2/XZ compression and decompression for browsers and Node.js, using liblzma compiled to WebAssembly",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "LICENSE.liblzma"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc && cp src/lzma.js src/lzma.wasm src/lzma.d.ts dist/",
+    "build:wasm": "./src/build.sh",
+    "test": "npm run build && tsc -p test && node --test test-dist/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "lzma",
+    "lzma2",
+    "xz",
+    "compression",
+    "wasm",
+    "webassembly"
+  ],
+  "author": "Taktik sa - B12 Consulting",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/icure/lzma-wasm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/icure/lzma-wasm/issues"
+  },
+  "homepage": "https://github.com/icure/lzma-wasm#readme",
+  "devDependencies": {
+    "@types/node": "^18.19.75",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}