lody 0.41.0 → 0.41.2-next.1

package/dist/chunks/index.node-CFS71Czb.js

@@ -0,0 +1,737 @@
+import { g as getDefaultExportFromCjs, __tla as __tla_0 } from "../index.js";
+import fs__default from "fs/promises";
+import path__default from "path";
+let index_node$1;
+let __tla = Promise.all([
+  (() => {
+    try {
+      return __tla_0;
+    } catch {
+    }
+  })()
+]).then(async () => {
+  function _mergeNamespaces(n, m) {
+    for (var i = 0; i < m.length; i++) {
+      const e = m[i];
+      if (typeof e !== "string" && !Array.isArray(e)) {
+        for (const k in e) {
+          if (k !== "default" && !(k in n)) {
+            const d = Object.getOwnPropertyDescriptor(e, k);
+            if (d) {
+              Object.defineProperty(n, k, d.get ? d : {
+                enumerable: true,
+                get: () => e[k]
+              });
+            }
+          }
+        }
+      }
+    }
+    return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, {
+      value: "Module"
+    }));
+  }
+  var index_node$2 = {};
+  var module$1 = {};
+  var zstd = {};
+  var hasRequiredZstd;
+  function requireZstd() {
+    if (hasRequiredZstd) return zstd;
+    hasRequiredZstd = 1;
+    Object.defineProperty(zstd, "__esModule", {
+      value: true
+    });
+    zstd.Module = void 0;
+    var Module = typeof Module !== "undefined" ? Module : {};
+    zstd.Module = Module;
+    var moduleOverrides = {};
+    var key;
+    for (key in Module) {
+      if (Module.hasOwnProperty(key)) {
+        moduleOverrides[key] = Module[key];
+      }
+    }
+    var err = Module["printErr"] || console.warn.bind(console);
+    for (key in moduleOverrides) {
+      if (moduleOverrides.hasOwnProperty(key)) {
+        Module[key] = moduleOverrides[key];
+      }
+    }
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    moduleOverrides = null;
+    if (Module["arguments"]) Module["arguments"];
+    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+    if (Module["quit"]) quit_ = Module["quit"];
+    if (typeof WebAssembly !== "object") {
+      abort("no native wasm support detected");
+    }
+    var wasmMemory;
+    var ABORT = false;
+    var EXITSTATUS;
+    var HEAPU8;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      Module["HEAP8"] = new Int8Array(b);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+    }
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATPOSTRUN__ = [];
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function") Module["preRun"] = [
+          Module["preRun"]
+        ];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(__ATPRERUN__);
+    }
+    function initRuntime() {
+      callRuntimeCallbacks(__ATINIT__);
+    }
+    function postRun() {
+      if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function") Module["postRun"] = [
+          Module["postRun"]
+        ];
+        while (Module["postRun"].length) {
+          addOnPostRun(Module["postRun"].shift());
+        }
+      }
+      callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    function addOnPreRun(cb) {
+      __ATPRERUN__.unshift(cb);
+    }
+    function addOnInit(cb) {
+      __ATINIT__.unshift(cb);
+    }
+    function addOnPostRun(cb) {
+      __ATPOSTRUN__.unshift(cb);
+    }
+    var runDependencies = 0;
+    var dependenciesFulfilled = null;
+    function addRunDependency(id) {
+      var _a;
+      runDependencies++;
+      (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies);
+    }
+    function removeRunDependency(id) {
+      var _a;
+      runDependencies--;
+      (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies);
+      if (runDependencies == 0) {
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      var _a;
+      (_a = Module["onAbort"]) === null || _a === void 0 ? void 0 : _a.call(Module, what);
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      throw e;
+    }
+    function getWasmImports() {
+      return {
+        a: wasmImports
+      };
+    }
+    function getBinaryPromise(url) {
+      return fetch(url, {
+        credentials: "same-origin"
+      }).then(function(response) {
+        if (!response["ok"]) {
+          throw "failed to load wasm binary file at '" + url + "'";
+        }
+        return response["arrayBuffer"]();
+      });
+    }
+    function init(filePathOrBuf) {
+      var info = getWasmImports();
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmMemory = wasmExports["f"];
+        updateMemoryViews();
+        addOnInit(wasmExports["g"]);
+        removeRunDependency();
+        return wasmExports;
+      }
+      addRunDependency();
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"]);
+      }
+      function instantiateArrayBuffer(receiver) {
+        return getBinaryPromise(filePathOrBuf).then(function(binary) {
+          var result = WebAssembly.instantiate(binary, info);
+          return result;
+        }).then(receiver, function(reason) {
+          err("failed to asynchronously prepare wasm: " + reason);
+          abort(reason);
+        });
+      }
+      function instantiateAsync() {
+        if (filePathOrBuf && filePathOrBuf.byteLength > 0) {
+          return WebAssembly.instantiate(filePathOrBuf, info).then(receiveInstantiationResult, function(reason) {
+            err("wasm compile failed: " + reason);
+          });
+        } else if (typeof WebAssembly.instantiateStreaming === "function" && typeof filePathOrBuf === "string" && typeof fetch === "function") {
+          return fetch(filePathOrBuf, {
+            credentials: "same-origin"
+          }).then(function(response) {
+            var result = WebAssembly.instantiateStreaming(response, info);
+            return result.then(receiveInstantiationResult, function(reason) {
+              err("wasm streaming compile failed: " + reason);
+              err("falling back to ArrayBuffer instantiation");
+              return instantiateArrayBuffer(receiveInstantiationResult);
+            });
+          });
+        } else {
+          return instantiateArrayBuffer(receiveInstantiationResult);
+        }
+      }
+      if (Module["instantiateWasm"]) {
+        try {
+          var exports$1 = Module["instantiateWasm"](info, receiveInstance);
+          return exports$1;
+        } catch (e) {
+          err("Module.instantiateWasm callback failed with error: " + e);
+          return false;
+        }
+      }
+      instantiateAsync();
+      return {};
+    }
+    class ExitStatus {
+      constructor(status) {
+        this.name = "ExitStatus";
+        this.message = `Program terminated with exit(${status})`;
+        this.status = status;
+      }
+    }
+    var callRuntimeCallbacks = (callbacks) => {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    };
+    var noExitRuntime = Module["noExitRuntime"] || true;
+    var __abort_js = () => abort("");
+    var runtimeKeepaliveCounter = 0;
+    var __emscripten_runtime_keepalive_clear = () => {
+      noExitRuntime = false;
+      runtimeKeepaliveCounter = 0;
+    };
+    var timers = {};
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var _proc_exit = (code) => {
+      var _a;
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        (_a = Module["onExit"]) === null || _a === void 0 ? void 0 : _a.call(Module, code);
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var maybeExit = () => {
+      if (!keepRuntimeAlive()) {
+        try {
+          _exit(EXITSTATUS);
+        } catch (e) {
+          handleException(e);
+        }
+      }
+    };
+    var callUserCallback = (func) => {
+      if (ABORT) {
+        return;
+      }
+      try {
+        func();
+        maybeExit();
+      } catch (e) {
+        handleException(e);
+      }
+    };
+    var _emscripten_get_now = () => performance.now();
+    var __setitimer_js = (which, timeout_ms) => {
+      if (timers[which]) {
+        clearTimeout(timers[which].id);
+        delete timers[which];
+      }
+      if (!timeout_ms) return 0;
+      var id = setTimeout(() => {
+        delete timers[which];
+        callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
+      }, timeout_ms);
+      timers[which] = {
+        id,
+        timeout_ms
+      };
+      return 0;
+    };
+    var getHeapMax = () => 2147483648;
+    var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+    var growMemory = (size) => {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 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 + 0.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 wasmImports = {
+      c: __abort_js,
+      b: __emscripten_runtime_keepalive_clear,
+      d: __setitimer_js,
+      e: _emscripten_resize_heap,
+      a: _proc_exit
+    };
+    var wasmExports;
+    Module["_ZSTD_isError"] = (a0) => (Module["_ZSTD_isError"] = wasmExports["h"])(a0);
+    Module["_ZSTD_compressBound"] = (a0) => (Module["_ZSTD_compressBound"] = wasmExports["i"])(a0);
+    Module["_ZSTD_createCCtx"] = () => (Module["_ZSTD_createCCtx"] = wasmExports["j"])();
+    Module["_ZSTD_freeCCtx"] = (a0) => (Module["_ZSTD_freeCCtx"] = wasmExports["k"])(a0);
+    Module["_ZSTD_compress_usingDict"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (Module["_ZSTD_compress_usingDict"] = wasmExports["l"])(a0, a1, a2, a3, a4, a5, a6, a7);
+    Module["_ZSTD_compress"] = (a0, a1, a2, a3, a4) => (Module["_ZSTD_compress"] = wasmExports["m"])(a0, a1, a2, a3, a4);
+    Module["_ZSTD_createDCtx"] = () => (Module["_ZSTD_createDCtx"] = wasmExports["n"])();
+    Module["_ZSTD_freeDCtx"] = (a0) => (Module["_ZSTD_freeDCtx"] = wasmExports["o"])(a0);
+    Module["_ZSTD_getFrameContentSize"] = (a0, a1) => (Module["_ZSTD_getFrameContentSize"] = wasmExports["p"])(a0, a1);
+    Module["_ZSTD_decompress_usingDict"] = (a0, a1, a2, a3, a4, a5, a6) => (Module["_ZSTD_decompress_usingDict"] = wasmExports["q"])(a0, a1, a2, a3, a4, a5, a6);
+    Module["_ZSTD_decompress"] = (a0, a1, a2, a3) => (Module["_ZSTD_decompress"] = wasmExports["r"])(a0, a1, a2, a3);
+    Module["_malloc"] = (a0) => (Module["_malloc"] = wasmExports["s"])(a0);
+    Module["_free"] = (a0) => (Module["_free"] = wasmExports["t"])(a0);
+    var __emscripten_timeout = (a0, a1) => (__emscripten_timeout = wasmExports["v"])(a0, a1);
+    var calledRun;
+    dependenciesFulfilled = function runCaller() {
+      if (!calledRun) run();
+      if (!calledRun) dependenciesFulfilled = runCaller;
+    };
+    function run() {
+      if (runDependencies > 0) {
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        return;
+      }
+      function doRun() {
+        var _a;
+        if (calledRun) return;
+        calledRun = true;
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        (_a = Module["onRuntimeInitialized"]) === null || _a === void 0 ? void 0 : _a.call(Module);
+        postRun();
+      }
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+          setTimeout(() => Module["setStatus"](""), 1);
+          doRun();
+        }, 1);
+      } else {
+        doRun();
+      }
+    }
+    Module["run"] = run;
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function") Module["preInit"] = [
+        Module["preInit"]
+      ];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].pop()();
+      }
+    }
+    Module["init"] = init;
+    return zstd;
+  }
+  var hasRequiredModule;
+  function requireModule() {
+    if (hasRequiredModule) return module$1;
+    hasRequiredModule = 1;
+    (function(exports$1) {
+      var __awaiter = module$1 && module$1.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      Object.defineProperty(exports$1, "__esModule", {
+        value: true
+      });
+      exports$1.Module = exports$1.waitInitialized = void 0;
+      const zstd_1 = requireZstd();
+      Object.defineProperty(exports$1, "Module", {
+        enumerable: true,
+        get: function() {
+          return zstd_1.Module;
+        }
+      });
+      const initialized = (() => new Promise((resolve) => {
+        zstd_1.Module.onRuntimeInitialized = resolve;
+      }))();
+      const waitInitialized = () => __awaiter(void 0, void 0, void 0, function* () {
+        yield initialized;
+      });
+      exports$1.waitInitialized = waitInitialized;
+    })(module$1);
+    return module$1;
+  }
+  var decompress = {};
+  var errors = {};
+  var hasRequiredErrors;
+  function requireErrors() {
+    if (hasRequiredErrors) return errors;
+    hasRequiredErrors = 1;
+    Object.defineProperty(errors, "__esModule", {
+      value: true
+    });
+    errors.isError = void 0;
+    const module_1 = requireModule();
+    const isError = (code) => {
+      const _isError = module_1.Module["_ZSTD_isError"];
+      return _isError(code);
+    };
+    errors.isError = isError;
+    return errors;
+  }
+  var hasRequiredDecompress;
+  function requireDecompress() {
+    if (hasRequiredDecompress) return decompress;
+    hasRequiredDecompress = 1;
+    Object.defineProperty(decompress, "__esModule", {
+      value: true
+    });
+    decompress.decompress = void 0;
+    const module_1 = requireModule();
+    const errors_1 = requireErrors();
+    const getFrameContentSize = (src, size) => {
+      const getSize = module_1.Module["_ZSTD_getFrameContentSize"];
+      return getSize(src, size);
+    };
+    const decompress$1 = (buf, opts = {
+      defaultHeapSize: 1024 * 1024
+    }) => {
+      const malloc = module_1.Module["_malloc"];
+      const src = malloc(buf.byteLength);
+      module_1.Module.HEAP8.set(buf, src);
+      const contentSize = getFrameContentSize(src, buf.byteLength);
+      const size = contentSize === -1 ? opts.defaultHeapSize : contentSize;
+      const free = module_1.Module["_free"];
+      const heap = malloc(size);
+      try {
+        const _decompress = module_1.Module["_ZSTD_decompress"];
+        const sizeOrError = _decompress(heap, size, src, buf.byteLength);
+        if ((0, errors_1.isError)(sizeOrError)) {
+          throw new Error(`Failed to compress with code ${sizeOrError}`);
+        }
+        const data = new Uint8Array(module_1.Module.HEAPU8.buffer, heap, sizeOrError).slice();
+        free(heap, size);
+        free(src, buf.byteLength);
+        return data;
+      } catch (e) {
+        free(heap, size);
+        free(src, buf.byteLength);
+        throw e;
+      }
+    };
+    decompress.decompress = decompress$1;
+    return decompress;
+  }
+  var compress = {};
+  var hasRequiredCompress;
+  function requireCompress() {
+    if (hasRequiredCompress) return compress;
+    hasRequiredCompress = 1;
+    Object.defineProperty(compress, "__esModule", {
+      value: true
+    });
+    compress.compress = void 0;
+    const module_1 = requireModule();
+    const errors_1 = requireErrors();
+    const compressBound = (size) => {
+      const bound = module_1.Module["_ZSTD_compressBound"];
+      return bound(size);
+    };
+    const compress$1 = (buf, level) => {
+      const bound = compressBound(buf.byteLength);
+      const malloc = module_1.Module["_malloc"];
+      const compressed = malloc(bound);
+      const src = malloc(buf.byteLength);
+      module_1.Module.HEAP8.set(buf, src);
+      const free = module_1.Module["_free"];
+      try {
+        const _compress = module_1.Module["_ZSTD_compress"];
+        const sizeOrError = _compress(compressed, bound, src, buf.byteLength, level !== null && level !== void 0 ? level : 3);
+        if ((0, errors_1.isError)(sizeOrError)) {
+          throw new Error(`Failed to compress with code ${sizeOrError}`);
+        }
+        const data = new Uint8Array(module_1.Module.HEAPU8.buffer, compressed, sizeOrError).slice();
+        free(compressed, bound);
+        free(src, buf.byteLength);
+        return data;
+      } catch (e) {
+        free(compressed, bound);
+        free(src, buf.byteLength);
+        throw e;
+      }
+    };
+    compress.compress = compress$1;
+    return compress;
+  }
+  var decompress_using_dict = {};
+  var hasRequiredDecompress_using_dict;
+  function requireDecompress_using_dict() {
+    if (hasRequiredDecompress_using_dict) return decompress_using_dict;
+    hasRequiredDecompress_using_dict = 1;
+    Object.defineProperty(decompress_using_dict, "__esModule", {
+      value: true
+    });
+    decompress_using_dict.decompressUsingDict = decompress_using_dict.freeDCtx = decompress_using_dict.createDCtx = void 0;
+    const module_1 = requireModule();
+    const errors_1 = requireErrors();
+    const getFrameContentSize = (src, size) => {
+      const getSize = module_1.Module["_ZSTD_getFrameContentSize"];
+      return getSize(src, size);
+    };
+    const createDCtx = () => {
+      return module_1.Module["_ZSTD_createDCtx"]();
+    };
+    decompress_using_dict.createDCtx = createDCtx;
+    const freeDCtx = (dctx) => {
+      return module_1.Module["_ZSTD_freeDCtx"](dctx);
+    };
+    decompress_using_dict.freeDCtx = freeDCtx;
+    const decompressUsingDict = (dctx, buf, dict, opts = {
+      defaultHeapSize: 1024 * 1024
+    }) => {
+      const malloc = module_1.Module["_malloc"];
+      const src = malloc(buf.byteLength);
+      module_1.Module.HEAP8.set(buf, src);
+      const pdict = malloc(dict.byteLength);
+      module_1.Module.HEAP8.set(dict, pdict);
+      const contentSize = getFrameContentSize(src, buf.byteLength);
+      const size = contentSize === -1 ? opts.defaultHeapSize : contentSize;
+      const free = module_1.Module["_free"];
+      const heap = malloc(size);
+      try {
+        const _decompress = module_1.Module["_ZSTD_decompress_usingDict"];
+        const sizeOrError = _decompress(dctx, heap, size, src, buf.byteLength, pdict, dict.byteLength);
+        if ((0, errors_1.isError)(sizeOrError)) {
+          throw new Error(`Failed to compress with code ${sizeOrError}`);
+        }
+        const data = new Uint8Array(module_1.Module.HEAPU8.buffer, heap, sizeOrError).slice();
+        free(heap, size);
+        free(src, buf.byteLength);
+        free(pdict, dict.byteLength);
+        return data;
+      } catch (e) {
+        free(heap, size);
+        free(src, buf.byteLength);
+        free(pdict, dict.byteLength);
+        throw e;
+      }
+    };
+    decompress_using_dict.decompressUsingDict = decompressUsingDict;
+    return decompress_using_dict;
+  }
+  var compress_using_dict = {};
+  var hasRequiredCompress_using_dict;
+  function requireCompress_using_dict() {
+    if (hasRequiredCompress_using_dict) return compress_using_dict;
+    hasRequiredCompress_using_dict = 1;
+    Object.defineProperty(compress_using_dict, "__esModule", {
+      value: true
+    });
+    compress_using_dict.compressUsingDict = compress_using_dict.freeCCtx = compress_using_dict.createCCtx = void 0;
+    const module_1 = requireModule();
+    const errors_1 = requireErrors();
+    const compressBound = (size) => {
+      const bound = module_1.Module["_ZSTD_compressBound"];
+      return bound(size);
+    };
+    const createCCtx = () => {
+      return module_1.Module["_ZSTD_createCCtx"]();
+    };
+    compress_using_dict.createCCtx = createCCtx;
+    const freeCCtx = (cctx) => {
+      return module_1.Module["_ZSTD_freeCCtx"](cctx);
+    };
+    compress_using_dict.freeCCtx = freeCCtx;
+    const compressUsingDict = (cctx, buf, dict, level) => {
+      const bound = compressBound(buf.byteLength);
+      const malloc = module_1.Module["_malloc"];
+      const compressed = malloc(bound);
+      const src = malloc(buf.byteLength);
+      module_1.Module.HEAP8.set(buf, src);
+      const pdict = malloc(dict.byteLength);
+      module_1.Module.HEAP8.set(dict, pdict);
+      const free = module_1.Module["_free"];
+      try {
+        const _compress = module_1.Module["_ZSTD_compress_usingDict"];
+        const sizeOrError = _compress(cctx, compressed, bound, src, buf.byteLength, pdict, dict.byteLength, level !== null && level !== void 0 ? level : 3);
+        if ((0, errors_1.isError)(sizeOrError)) {
+          throw new Error(`Failed to compress with code ${sizeOrError}`);
+        }
+        const data = new Uint8Array(module_1.Module.HEAPU8.buffer, compressed, sizeOrError).slice();
+        free(compressed, bound);
+        free(src, buf.byteLength);
+        free(pdict, dict.byteLength);
+        return data;
+      } catch (e) {
+        free(compressed, bound);
+        free(src, buf.byteLength);
+        free(pdict, dict.byteLength);
+        throw e;
+      }
+    };
+    compress_using_dict.compressUsingDict = compressUsingDict;
+    return compress_using_dict;
+  }
+  var hasRequiredIndex_node;
+  function requireIndex_node() {
+    if (hasRequiredIndex_node) return index_node$2;
+    hasRequiredIndex_node = 1;
+    (function(exports$1) {
+      var __createBinding = index_node$2 && index_node$2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === void 0) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function() {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }) : (function(o, m, k, k2) {
+        if (k2 === void 0) k2 = k;
+        o[k2] = m[k];
+      }));
+      var __exportStar = index_node$2 && index_node$2.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
+      };
+      var __awaiter = index_node$2 && index_node$2.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      Object.defineProperty(exports$1, "__esModule", {
+        value: true
+      });
+      exports$1.init = void 0;
+      const module_1 = requireModule();
+      const init = () => __awaiter(void 0, void 0, void 0, function* () {
+        const { readFile } = fs__default;
+        const { resolve } = path__default;
+        const buf = yield readFile(resolve(__dirname, "./zstd.wasm"));
+        module_1.Module["init"](buf);
+        yield (0, module_1.waitInitialized)();
+      });
+      exports$1.init = init;
+      __exportStar(requireDecompress(), exports$1);
+      __exportStar(requireCompress(), exports$1);
+      __exportStar(requireDecompress_using_dict(), exports$1);
+      __exportStar(requireCompress_using_dict(), exports$1);
+    })(index_node$2);
+    return index_node$2;
+  }
+  var index_nodeExports = requireIndex_node();
+  const index_node = getDefaultExportFromCjs(index_nodeExports);
+  index_node$1 = _mergeNamespaces({
+    __proto__: null,
+    default: index_node
+  }, [
+    index_nodeExports
+  ]);
+});
+export {
+  __tla,
+  index_node$1 as i
+};