@xyo-network/hash 2.90.11 → 2.90.13

package/dist/browser/worker/wasmHash-bundle.js

@@ -0,0 +1,893 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../../../../../../node_modules/is-observable/index.js
+  var require_is_observable = __commonJS({
+    "../../../../../../node_modules/is-observable/index.js"(exports, module) {
+      "use strict";
+      module.exports = (value) => {
+        if (!value) {
+          return false;
+        }
+        if (typeof Symbol.observable === "symbol" && typeof value[Symbol.observable] === "function") {
+          return value === value[Symbol.observable]();
+        }
+        if (typeof value["@@observable"] === "function") {
+          return value === value["@@observable"]();
+        }
+        return false;
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/serializers.js
+  var require_serializers = __commonJS({
+    "../../../../../../node_modules/threads/dist/serializers.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.DefaultSerializer = exports.extendSerializer = void 0;
+      function extendSerializer(extend, implementation) {
+        const fallbackDeserializer = extend.deserialize.bind(extend);
+        const fallbackSerializer = extend.serialize.bind(extend);
+        return {
+          deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+          },
+          serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+          }
+        };
+      }
+      exports.extendSerializer = extendSerializer;
+      var DefaultErrorSerializer = {
+        deserialize(message) {
+          return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack
+          });
+        },
+        serialize(error) {
+          return {
+            __error_marker: "$$error",
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+          };
+        }
+      };
+      var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+      exports.DefaultSerializer = {
+        deserialize(message) {
+          if (isSerializedError(message)) {
+            return DefaultErrorSerializer.deserialize(message);
+          } else {
+            return message;
+          }
+        },
+        serialize(input) {
+          if (input instanceof Error) {
+            return DefaultErrorSerializer.serialize(input);
+          } else {
+            return input;
+          }
+        }
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/common.js
+  var require_common = __commonJS({
+    "../../../../../../node_modules/threads/dist/common.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.serialize = exports.deserialize = exports.registerSerializer = void 0;
+      var serializers_1 = require_serializers();
+      var registeredSerializer = serializers_1.DefaultSerializer;
+      function registerSerializer2(serializer) {
+        registeredSerializer = serializers_1.extendSerializer(registeredSerializer, serializer);
+      }
+      exports.registerSerializer = registerSerializer2;
+      function deserialize(message) {
+        return registeredSerializer.deserialize(message);
+      }
+      exports.deserialize = deserialize;
+      function serialize(input) {
+        return registeredSerializer.serialize(input);
+      }
+      exports.serialize = serialize;
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/symbols.js
+  var require_symbols = __commonJS({
+    "../../../../../../node_modules/threads/dist/symbols.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+      exports.$errors = Symbol("thread.errors");
+      exports.$events = Symbol("thread.events");
+      exports.$terminate = Symbol("thread.terminate");
+      exports.$transferable = Symbol("thread.transferable");
+      exports.$worker = Symbol("thread.worker");
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/transferable.js
+  var require_transferable = __commonJS({
+    "../../../../../../node_modules/threads/dist/transferable.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.Transfer = exports.isTransferDescriptor = void 0;
+      var symbols_1 = require_symbols();
+      function isTransferable(thing) {
+        if (!thing || typeof thing !== "object")
+          return false;
+        return true;
+      }
+      function isTransferDescriptor(thing) {
+        return thing && typeof thing === "object" && thing[symbols_1.$transferable];
+      }
+      exports.isTransferDescriptor = isTransferDescriptor;
+      function Transfer2(payload, transferables) {
+        if (!transferables) {
+          if (!isTransferable(payload))
+            throw Error();
+          transferables = [payload];
+        }
+        return {
+          [symbols_1.$transferable]: true,
+          send: payload,
+          transferables
+        };
+      }
+      exports.Transfer = Transfer2;
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/types/messages.js
+  var require_messages = __commonJS({
+    "../../../../../../node_modules/threads/dist/types/messages.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.WorkerMessageType = exports.MasterMessageType = void 0;
+      var MasterMessageType;
+      (function(MasterMessageType2) {
+        MasterMessageType2["cancel"] = "cancel";
+        MasterMessageType2["run"] = "run";
+      })(MasterMessageType = exports.MasterMessageType || (exports.MasterMessageType = {}));
+      var WorkerMessageType;
+      (function(WorkerMessageType2) {
+        WorkerMessageType2["error"] = "error";
+        WorkerMessageType2["init"] = "init";
+        WorkerMessageType2["result"] = "result";
+        WorkerMessageType2["running"] = "running";
+        WorkerMessageType2["uncaughtError"] = "uncaughtError";
+      })(WorkerMessageType = exports.WorkerMessageType || (exports.WorkerMessageType = {}));
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/worker/implementation.browser.js
+  var require_implementation_browser = __commonJS({
+    "../../../../../../node_modules/threads/dist/worker/implementation.browser.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var isWorkerRuntime = function isWorkerRuntime2() {
+        const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+        return typeof self !== "undefined" && self.postMessage && !isWindowContext ? true : false;
+      };
+      var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+        self.postMessage(data, transferList);
+      };
+      var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
+        const messageHandler = (messageEvent) => {
+          onMessage(messageEvent.data);
+        };
+        const unsubscribe = () => {
+          self.removeEventListener("message", messageHandler);
+        };
+        self.addEventListener("message", messageHandler);
+        return unsubscribe;
+      };
+      exports.default = {
+        isWorkerRuntime,
+        postMessageToMaster,
+        subscribeToMasterMessages
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/worker/index.js
+  var require_worker = __commonJS({
+    "../../../../../../node_modules/threads/dist/worker/index.js"(exports) {
+      "use strict";
+      var __awaiter2 = exports && exports.__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());
+        });
+      };
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.expose = exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+      var is_observable_1 = __importDefault(require_is_observable());
+      var common_1 = require_common();
+      var transferable_1 = require_transferable();
+      var messages_1 = require_messages();
+      var implementation_1 = __importDefault(require_implementation_browser());
+      var common_2 = require_common();
+      Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function() {
+        return common_2.registerSerializer;
+      } });
+      var transferable_2 = require_transferable();
+      Object.defineProperty(exports, "Transfer", { enumerable: true, get: function() {
+        return transferable_2.Transfer;
+      } });
+      exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
+      var exposeCalled = false;
+      var activeSubscriptions = /* @__PURE__ */ new Map();
+      var isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+      var isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+      var isObservable = (thing) => is_observable_1.default(thing) || isZenObservable(thing);
+      function isZenObservable(thing) {
+        return thing && typeof thing === "object" && typeof thing.subscribe === "function";
+      }
+      function deconstructTransfer(thing) {
+        return transferable_1.isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      }
+      function postFunctionInitMessage() {
+        const initMessage = {
+          type: messages_1.WorkerMessageType.init,
+          exposed: {
+            type: "function"
+          }
+        };
+        implementation_1.default.postMessageToMaster(initMessage);
+      }
+      function postModuleInitMessage(methodNames) {
+        const initMessage = {
+          type: messages_1.WorkerMessageType.init,
+          exposed: {
+            type: "module",
+            methods: methodNames
+          }
+        };
+        implementation_1.default.postMessageToMaster(initMessage);
+      }
+      function postJobErrorMessage(uid, rawError) {
+        const { payload: error, transferables } = deconstructTransfer(rawError);
+        const errorMessage = {
+          type: messages_1.WorkerMessageType.error,
+          uid,
+          error: common_1.serialize(error)
+        };
+        implementation_1.default.postMessageToMaster(errorMessage, transferables);
+      }
+      function postJobResultMessage(uid, completed, resultValue) {
+        const { payload, transferables } = deconstructTransfer(resultValue);
+        const resultMessage = {
+          type: messages_1.WorkerMessageType.result,
+          uid,
+          complete: completed ? true : void 0,
+          payload
+        };
+        implementation_1.default.postMessageToMaster(resultMessage, transferables);
+      }
+      function postJobStartMessage(uid, resultType) {
+        const startMessage = {
+          type: messages_1.WorkerMessageType.running,
+          uid,
+          resultType
+        };
+        implementation_1.default.postMessageToMaster(startMessage);
+      }
+      function postUncaughtErrorMessage(error) {
+        try {
+          const errorMessage = {
+            type: messages_1.WorkerMessageType.uncaughtError,
+            error: common_1.serialize(error)
+          };
+          implementation_1.default.postMessageToMaster(errorMessage);
+        } catch (subError) {
+          console.error("Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:", subError, "\nOriginal error:", error);
+        }
+      }
+      function runFunction(jobUID, fn, args) {
+        return __awaiter2(this, void 0, void 0, function* () {
+          let syncResult;
+          try {
+            syncResult = fn(...args);
+          } catch (error) {
+            return postJobErrorMessage(jobUID, error);
+          }
+          const resultType = isObservable(syncResult) ? "observable" : "promise";
+          postJobStartMessage(jobUID, resultType);
+          if (isObservable(syncResult)) {
+            const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, common_1.serialize(value)), (error) => {
+              postJobErrorMessage(jobUID, common_1.serialize(error));
+              activeSubscriptions.delete(jobUID);
+            }, () => {
+              postJobResultMessage(jobUID, true);
+              activeSubscriptions.delete(jobUID);
+            });
+            activeSubscriptions.set(jobUID, subscription);
+          } else {
+            try {
+              const result = yield syncResult;
+              postJobResultMessage(jobUID, true, common_1.serialize(result));
+            } catch (error) {
+              postJobErrorMessage(jobUID, common_1.serialize(error));
+            }
+          }
+        });
+      }
+      function expose2(exposed) {
+        if (!implementation_1.default.isWorkerRuntime()) {
+          throw Error("expose() called in the master thread.");
+        }
+        if (exposeCalled) {
+          throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+        }
+        exposeCalled = true;
+        if (typeof exposed === "function") {
+          implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+              runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
+            }
+          });
+          postFunctionInitMessage();
+        } else if (typeof exposed === "object" && exposed) {
+          implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+              runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
+            }
+          });
+          const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === "function");
+          postModuleInitMessage(methodNames);
+        } else {
+          throw Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+        }
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+              subscription.unsubscribe();
+              activeSubscriptions.delete(jobUID);
+            }
+          }
+        });
+      }
+      exports.expose = expose2;
+      if (typeof self !== "undefined" && typeof self.addEventListener === "function" && implementation_1.default.isWorkerRuntime()) {
+        self.addEventListener("error", (event) => {
+          setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+        });
+        self.addEventListener("unhandledrejection", (event) => {
+          const error = event.reason;
+          if (error && typeof error.message === "string") {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+          }
+        });
+      }
+      if (typeof process !== "undefined" && typeof process.on === "function" && implementation_1.default.isWorkerRuntime()) {
+        process.on("uncaughtException", (error) => {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        });
+        process.on("unhandledRejection", (error) => {
+          if (error && typeof error.message === "string") {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+          }
+        });
+      }
+    }
+  });
+
+  // ../../../../../../node_modules/@xylabs/hex/dist/node/index.js
+  var assertError = (value, assert, defaultMessage) => {
+    if (assert) {
+      const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+      if (assertString) {
+        throw new Error(assertString === true ? defaultMessage : assertString);
+      }
+    }
+    return void 0;
+  };
+  var bitsToNibbles = (value) => {
+    const nibbles = value >> 2;
+    if (value !== nibbles << 2)
+      throw new Error("Bits for nibbles must multiple of 4");
+    return nibbles;
+  };
+  var hexRegex = /^[\da-f]+$/i;
+  var hexRegexWithPrefix = /0x[\da-f]+$/i;
+  var isHex = (value, config) => {
+    if (typeof value !== "string")
+      return false;
+    const valueCharLength = (config == null ? void 0 : config.prefix) ? value.length - 2 : value.length;
+    if ((config == null ? void 0 : config.bitLength) !== void 0 && valueCharLength !== bitsToNibbles(config == null ? void 0 : config.bitLength))
+      return false;
+    return (config == null ? void 0 : config.prefix) ? hexRegexWithPrefix.test(value) : hexRegex.test(value);
+  };
+  var hexFromHexString = (value, config = {}) => {
+    const { prefix = false, byteSize = 8 } = config;
+    const nibbleBoundary = bitsToNibbles(byteSize);
+    const unPadded = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+    if (isHex(unPadded)) {
+      const padded = unPadded.padStart(unPadded.length + unPadded.length % nibbleBoundary, "0");
+      return prefix ? `0x${padded}` : padded;
+    } else {
+      throw new Error("Received string is not a value hex");
+    }
+  };
+  var isHash = (value, bitLength = 256) => {
+    return isHex(value, { bitLength });
+  };
+  function asHash(value, assert) {
+    let stringValue = void 0;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value);
+        break;
+      }
+      default: {
+        return assert ? assertError(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+  }
+
+  // ../../../../../../node_modules/hash-wasm/dist/index.esm.js
+  function __awaiter(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());
+    });
+  }
+  var Mutex = class {
+    constructor() {
+      this.mutex = Promise.resolve();
+    }
+    lock() {
+      let begin = () => {
+      };
+      this.mutex = this.mutex.then(() => new Promise(begin));
+      return new Promise((res) => {
+        begin = res;
+      });
+    }
+    dispatch(fn) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const unlock = yield this.lock();
+        try {
+          return yield Promise.resolve(fn());
+        } finally {
+          unlock();
+        }
+      });
+    }
+  };
+  var _a;
+  function getGlobal() {
+    if (typeof globalThis !== "undefined")
+      return globalThis;
+    if (typeof self !== "undefined")
+      return self;
+    if (typeof window !== "undefined")
+      return window;
+    return global;
+  }
+  var globalObject = getGlobal();
+  var nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
+  var textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
+  function hexCharCodesToInt(a, b) {
+    return (a & 15) + (a >> 6 | a >> 3 & 8) << 4 | (b & 15) + (b >> 6 | b >> 3 & 8);
+  }
+  function writeHexToUInt8(buf, str) {
+    const size = str.length >> 1;
+    for (let i = 0; i < size; i++) {
+      const index = i << 1;
+      buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+    }
+  }
+  function hexStringEqualsUInt8(str, buf) {
+    if (str.length !== buf.length * 2) {
+      return false;
+    }
+    for (let i = 0; i < buf.length; i++) {
+      const strIndex = i << 1;
+      if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var alpha = "a".charCodeAt(0) - 10;
+  var digit = "0".charCodeAt(0);
+  function getDigestHex(tmpBuffer, input, hashLength) {
+    let p = 0;
+    for (let i = 0; i < hashLength; i++) {
+      let nibble = input[i] >>> 4;
+      tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+      nibble = input[i] & 15;
+      tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+    }
+    return String.fromCharCode.apply(null, tmpBuffer);
+  }
+  var getUInt8Buffer = nodeBuffer !== null ? (data) => {
+    if (typeof data === "string") {
+      const buf = nodeBuffer.from(data, "utf8");
+      return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+    }
+    if (nodeBuffer.isBuffer(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.length);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    throw new Error("Invalid data type!");
+  } : (data) => {
+    if (typeof data === "string") {
+      return textEncoder.encode(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    throw new Error("Invalid data type!");
+  };
+  var base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var base64Lookup = new Uint8Array(256);
+  for (let i = 0; i < base64Chars.length; i++) {
+    base64Lookup[base64Chars.charCodeAt(i)] = i;
+  }
+  function getDecodeBase64Length(data) {
+    let bufferLength = Math.floor(data.length * 0.75);
+    const len = data.length;
+    if (data[len - 1] === "=") {
+      bufferLength -= 1;
+      if (data[len - 2] === "=") {
+        bufferLength -= 1;
+      }
+    }
+    return bufferLength;
+  }
+  function decodeBase64(data) {
+    const bufferLength = getDecodeBase64Length(data);
+    const len = data.length;
+    const bytes = new Uint8Array(bufferLength);
+    let p = 0;
+    for (let i = 0; i < len; i += 4) {
+      const encoded1 = base64Lookup[data.charCodeAt(i)];
+      const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+      const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+      const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+      bytes[p] = encoded1 << 2 | encoded2 >> 4;
+      p += 1;
+      bytes[p] = (encoded2 & 15) << 4 | encoded3 >> 2;
+      p += 1;
+      bytes[p] = (encoded3 & 3) << 6 | encoded4 & 63;
+      p += 1;
+    }
+    return bytes;
+  }
+  var MAX_HEAP = 16 * 1024;
+  var WASM_FUNC_HASH_LENGTH = 4;
+  var wasmMutex = new Mutex();
+  var wasmModuleCache = /* @__PURE__ */ new Map();
+  function WASMInterface(binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let wasmInstance = null;
+      let memoryView = null;
+      let initialized = false;
+      if (typeof WebAssembly === "undefined") {
+        throw new Error("WebAssembly is not supported in this environment!");
+      }
+      const writeMemory = (data, offset = 0) => {
+        memoryView.set(data, offset);
+      };
+      const getMemory = () => memoryView;
+      const getExports = () => wasmInstance.exports;
+      const setMemorySize = (totalSize) => {
+        wasmInstance.exports.Hash_SetMemorySize(totalSize);
+        const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+      };
+      const getStateSize = () => {
+        const view = new DataView(wasmInstance.exports.memory.buffer);
+        const stateSize = view.getUint32(wasmInstance.exports.STATE_SIZE, true);
+        return stateSize;
+      };
+      const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
+        if (!wasmModuleCache.has(binary.name)) {
+          const asm = decodeBase64(binary.data);
+          const promise = WebAssembly.compile(asm);
+          wasmModuleCache.set(binary.name, promise);
+        }
+        const module = yield wasmModuleCache.get(binary.name);
+        wasmInstance = yield WebAssembly.instantiate(module, {
+          // env: {
+          //   emscripten_memcpy_big: (dest, src, num) => {
+          //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+          //     const memView = new Uint8Array(memoryBuffer, 0);
+          //     memView.set(memView.subarray(src, src + num), dest);
+          //   },
+          //   print_memory: (offset, len) => {
+          //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+          //     const memView = new Uint8Array(memoryBuffer, 0);
+          //     console.log('print_int32', memView.subarray(offset, offset + len));
+          //   },
+          // },
+        });
+      }));
+      const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
+        if (!wasmInstance) {
+          yield loadWASMPromise;
+        }
+        const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+      });
+      const init = (bits = null) => {
+        initialized = true;
+        wasmInstance.exports.Hash_Init(bits);
+      };
+      const updateUInt8Array = (data) => {
+        let read = 0;
+        while (read < data.length) {
+          const chunk = data.subarray(read, read + MAX_HEAP);
+          read += chunk.length;
+          memoryView.set(chunk);
+          wasmInstance.exports.Hash_Update(chunk.length);
+        }
+      };
+      const update = (data) => {
+        if (!initialized) {
+          throw new Error("update() called before init()");
+        }
+        const Uint8Buffer = getUInt8Buffer(data);
+        updateUInt8Array(Uint8Buffer);
+      };
+      const digestChars = new Uint8Array(hashLength * 2);
+      const digest = (outputType, padding = null) => {
+        if (!initialized) {
+          throw new Error("digest() called before init()");
+        }
+        initialized = false;
+        wasmInstance.exports.Hash_Final(padding);
+        if (outputType === "binary") {
+          return memoryView.slice(0, hashLength);
+        }
+        return getDigestHex(digestChars, memoryView, hashLength);
+      };
+      const save = () => {
+        if (!initialized) {
+          throw new Error("save() can only be called after init() and before digest()");
+        }
+        const stateOffset = wasmInstance.exports.Hash_GetState();
+        const stateLength = getStateSize();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+        const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+        writeHexToUInt8(prefixedState, binary.hash);
+        prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+        return prefixedState;
+      };
+      const load = (state) => {
+        if (!(state instanceof Uint8Array)) {
+          throw new Error("load() expects an Uint8Array generated by save()");
+        }
+        const stateOffset = wasmInstance.exports.Hash_GetState();
+        const stateLength = getStateSize();
+        const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        if (state.length !== overallLength) {
+          throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+        }
+        if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
+          throw new Error("This state was written by an incompatible hash implementation");
+        }
+        const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+        new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+        initialized = true;
+      };
+      const isDataShort = (data) => {
+        if (typeof data === "string") {
+          return data.length < MAX_HEAP / 4;
+        }
+        return data.byteLength < MAX_HEAP;
+      };
+      let canSimplify = isDataShort;
+      switch (binary.name) {
+        case "argon2":
+        case "scrypt":
+          canSimplify = () => true;
+          break;
+        case "blake2b":
+        case "blake2s":
+          canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
+          break;
+        case "blake3":
+          canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+          break;
+        case "xxhash64":
+        case "xxhash3":
+        case "xxhash128":
+          canSimplify = () => false;
+          break;
+      }
+      const calculate = (data, initParam = null, digestParam = null) => {
+        if (!canSimplify(data, initParam)) {
+          init(initParam);
+          update(data);
+          return digest("hex", digestParam);
+        }
+        const buffer = getUInt8Buffer(data);
+        memoryView.set(buffer);
+        wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
+        return getDigestHex(digestChars, memoryView, hashLength);
+      };
+      yield setupInterface();
+      return {
+        getMemory,
+        writeMemory,
+        getExports,
+        setMemorySize,
+        init,
+        update,
+        digest,
+        save,
+        load,
+        calculate,
+        hashLength
+      };
+    });
+  }
+  function lockedCreate(mutex2, binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield mutex2.lock();
+      const wasm = yield WASMInterface(binary, hashLength);
+      unlock();
+      return wasm;
+    });
+  }
+  var mutex$l = new Mutex();
+  var mutex$k = new Mutex();
+  var uint32View = new DataView(new ArrayBuffer(4));
+  var mutex$j = new Mutex();
+  var mutex$i = new Mutex();
+  var mutex$h = new Mutex();
+  var mutex$g = new Mutex();
+  var mutex$f = new Mutex();
+  var mutex$e = new Mutex();
+  var mutex$d = new Mutex();
+  var mutex$c = new Mutex();
+  var mutex$b = new Mutex();
+  var name$a = "sha256";
+  var data$a = "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";
+  var hash$a = "64f06674";
+  var wasmJson$a = {
+    name: name$a,
+    data: data$a,
+    hash: hash$a
+  };
+  var mutex$a = new Mutex();
+  var mutex$9 = new Mutex();
+  var wasmCache$9 = null;
+  function sha256(data) {
+    if (wasmCache$9 === null) {
+      return lockedCreate(mutex$9, wasmJson$a, 32).then((wasm) => {
+        wasmCache$9 = wasm;
+        return wasmCache$9.calculate(data, 256);
+      });
+    }
+    try {
+      const hash = wasmCache$9.calculate(data, 256);
+      return Promise.resolve(hash);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  var mutex$8 = new Mutex();
+  var mutex$7 = new Mutex();
+  var mutex$6 = new Mutex();
+  var mutex$5 = new Mutex();
+  var seedBuffer$2 = new ArrayBuffer(8);
+  var mutex$4 = new Mutex();
+  var seedBuffer$1 = new ArrayBuffer(8);
+  var mutex$3 = new Mutex();
+  var seedBuffer = new ArrayBuffer(8);
+  var mutex$2 = new Mutex();
+  var mutex$1 = new Mutex();
+  var mutex = new Mutex();
+
+  // ../../../../../../node_modules/threads/worker.mjs
+  var import_worker = __toESM(require_worker(), 1);
+  var expose = import_worker.default.expose;
+  var registerSerializer = import_worker.default.registerSerializer;
+  var Transfer = import_worker.default.Transfer;
+
+  // src/worker/wasmHash.ts
+  expose({
+    async hash(data) {
+      return asHash(await sha256(data), true);
+    }
+  });
+})();
+/*! Bundled license information:
+
+hash-wasm/dist/index.esm.js:
+  (*!
+   * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+   * (c) Dani Biro
+   * @license MIT
+   *)
+*/