@xyo-network/hash 2.90.12 → 2.90.13

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

@@ -0,0 +1,455 @@
+"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 __awaiter = 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 __awaiter(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/platform/dist/browser/index.js
+  var isBrowser = () => {
+    return !isWebworker() && window && window.document !== void 0;
+  };
+  var isWebworker = () => {
+    return typeof self === "object" && self.constructor?.name === "DedicatedWorkerGlobalScope";
+  };
+  var getGlobal = () => isWebworker() ? self : isBrowser() ? window : globalThis;
+  var subtle = getGlobal().crypto.subtle;
+
+  // ../../../../../../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/subtleHash.ts
+  expose({
+    async hash(data) {
+      return await subtle.digest("SHA-256", data);
+    }
+  });
+})();

package/dist/browser/worker/subtleHash.cjs

@@ -1,36 +1,11 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/worker/subtleHash.ts
-var subtleHash_exports = {};
-__export(subtleHash_exports, {
-  subtleHashFunc: () => subtleHashFunc
+var import_platform = require("@xylabs/platform");
+var import_worker = require("threads/worker");
+(0, import_worker.expose)({
+  async hash(data) {
+    return await import_platform.subtle.digest("SHA-256", data);
+  }
 });
-module.exports = __toCommonJS(subtleHash_exports);
-var subtleHashFunc = /* @__PURE__ */ __name(() => {
-  const { subtle } = require("@xylabs/platform");
-  const { expose } = require("threads/worker");
-  expose({
-    async hash(data) {
-      return await subtle.digest("SHA-256", data);
-    }
-  });
-}, "subtleHashFunc");
 //# sourceMappingURL=subtleHash.cjs.map

package/dist/browser/worker/subtleHash.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/worker/subtleHash.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nexport const subtleHashFunc = () => {\n  const { subtle } = require('@xylabs/platform')\n  // eslint-disable-next-line import/no-internal-modules\n  const { expose } = require('threads/worker')\n\n  expose({\n    async hash(data: ArrayBuffer) {\n      return await subtle.digest('SHA-256', data)\n    },\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AACO,IAAMA,iBAAiB,6BAAA;AAC5B,QAAM,EAAEC,OAAM,IAAKC,QAAQ,kBAAA;AAE3B,QAAM,EAAEC,OAAM,IAAKD,QAAQ,gBAAA;AAE3BC,SAAO;IACL,MAAMC,KAAKC,MAAiB;AAC1B,aAAO,MAAMJ,OAAOK,OAAO,WAAWD,IAAAA;IACxC;EACF,CAAA;AACF,GAV8B;","names":["subtleHashFunc","subtle","require","expose","hash","data","digest"]}
+{"version":3,"sources":["../../../src/worker/subtleHash.ts"],"sourcesContent":["import { subtle } from '@xylabs/platform'\n// eslint-disable-next-line import/no-internal-modules\nimport { expose } from 'threads/worker'\n\nexpose({\n  async hash(data: ArrayBuffer) {\n    return await subtle.digest('SHA-256', data)\n  },\n})\n"],"mappings":";;;AAAA,sBAAuB;AAEvB,oBAAuB;IAEvBA,sBAAO;EACL,MAAMC,KAAKC,MAAiB;AAC1B,WAAO,MAAMC,uBAAOC,OAAO,WAAWF,IAAAA;EACxC;AACF,CAAA;","names":["expose","hash","data","subtle","digest"]}

package/dist/browser/worker/subtleHash.d.cts

@@ -1,2 +1,2 @@
-export declare const subtleHashFunc: () => void;
+export {};
 //# sourceMappingURL=subtleHash.d.ts.map

package/dist/browser/worker/subtleHash.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}
+{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":""}

package/dist/browser/worker/subtleHash.d.mts

@@ -1,2 +1,2 @@
-export declare const subtleHashFunc: () => void;
+export {};
 //# sourceMappingURL=subtleHash.d.ts.map

package/dist/browser/worker/subtleHash.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}
+{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":""}

package/dist/browser/worker/subtleHash.d.ts

@@ -1,2 +1,2 @@
-export declare const subtleHashFunc: () => void;
+export {};
 //# sourceMappingURL=subtleHash.d.ts.map

package/dist/browser/worker/subtleHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}
+{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":""}

package/dist/browser/worker/subtleHash.js

@@ -1,24 +1,9 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/worker/subtleHash.ts
-var subtleHashFunc = /* @__PURE__ */ __name(() => {
-  const { subtle } = __require("@xylabs/platform");
-  const { expose } = __require("threads/worker");
-  expose({
-    async hash(data) {
-      return await subtle.digest("SHA-256", data);
-    }
-  });
-}, "subtleHashFunc");
-export {
-  subtleHashFunc
-};
+import { subtle } from "@xylabs/platform";
+import { expose } from "threads/worker";
+expose({
+  async hash(data) {
+    return await subtle.digest("SHA-256", data);
+  }
+});
 //# sourceMappingURL=subtleHash.js.map

package/dist/browser/worker/subtleHash.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/worker/subtleHash.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nexport const subtleHashFunc = () => {\n  const { subtle } = require('@xylabs/platform')\n  // eslint-disable-next-line import/no-internal-modules\n  const { expose } = require('threads/worker')\n\n  expose({\n    async hash(data: ArrayBuffer) {\n      return await subtle.digest('SHA-256', data)\n    },\n  })\n}\n"],"mappings":";;;;;;;;;;;AACO,IAAMA,iBAAiB,6BAAA;AAC5B,QAAM,EAAEC,OAAM,IAAKC,UAAQ,kBAAA;AAE3B,QAAM,EAAEC,OAAM,IAAKD,UAAQ,gBAAA;AAE3BC,SAAO;IACL,MAAMC,KAAKC,MAAiB;AAC1B,aAAO,MAAMJ,OAAOK,OAAO,WAAWD,IAAAA;IACxC;EACF,CAAA;AACF,GAV8B;","names":["subtleHashFunc","subtle","require","expose","hash","data","digest"]}
+{"version":3,"sources":["../../../src/worker/subtleHash.ts"],"sourcesContent":["import { subtle } from '@xylabs/platform'\n// eslint-disable-next-line import/no-internal-modules\nimport { expose } from 'threads/worker'\n\nexpose({\n  async hash(data: ArrayBuffer) {\n    return await subtle.digest('SHA-256', data)\n  },\n})\n"],"mappings":";AAAA,SAASA,cAAc;AAEvB,SAASC,cAAc;AAEvBA,OAAO;EACL,MAAMC,KAAKC,MAAiB;AAC1B,WAAO,MAAMH,OAAOI,OAAO,WAAWD,IAAAA;EACxC;AACF,CAAA;","names":["subtle","expose","hash","data","digest"]}

package/dist/browser/worker/subtleHashNode.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/worker/subtleHashNode.ts
+var subtleHashNode_exports = {};
+__export(subtleHashNode_exports, {
+  subtleHashFunc: () => subtleHashFunc
+});
+module.exports = __toCommonJS(subtleHashNode_exports);
+var subtleHashFunc = /* @__PURE__ */ __name(() => {
+  const { subtle } = require("@xylabs/platform");
+  const { expose } = require("threads/worker");
+  expose({
+    async hash(data) {
+      return await subtle.digest("SHA-256", data);
+    }
+  });
+}, "subtleHashFunc");
+//# sourceMappingURL=subtleHashNode.cjs.map

package/dist/browser/worker/subtleHashNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/worker/subtleHashNode.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nexport const subtleHashFunc = () => {\n  const { subtle } = require('@xylabs/platform')\n  // eslint-disable-next-line import/no-internal-modules\n  const { expose } = require('threads/worker')\n\n  expose({\n    async hash(data: ArrayBuffer) {\n      return await subtle.digest('SHA-256', data)\n    },\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AACO,IAAMA,iBAAiB,6BAAA;AAC5B,QAAM,EAAEC,OAAM,IAAKC,QAAQ,kBAAA;AAE3B,QAAM,EAAEC,OAAM,IAAKD,QAAQ,gBAAA;AAE3BC,SAAO;IACL,MAAMC,KAAKC,MAAiB;AAC1B,aAAO,MAAMJ,OAAOK,OAAO,WAAWD,IAAAA;IACxC;EACF,CAAA;AACF,GAV8B;","names":["subtleHashFunc","subtle","require","expose","hash","data","digest"]}

package/dist/browser/worker/subtleHashNode.d.cts

@@ -0,0 +1,2 @@
+export declare const subtleHashFunc: () => void;
+//# sourceMappingURL=subtleHashNode.d.ts.map

package/dist/browser/worker/subtleHashNode.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtleHashNode.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHashNode.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}

package/dist/browser/worker/subtleHashNode.d.mts

@@ -0,0 +1,2 @@
+export declare const subtleHashFunc: () => void;
+//# sourceMappingURL=subtleHashNode.d.ts.map

package/dist/browser/worker/subtleHashNode.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtleHashNode.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHashNode.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}

package/dist/browser/worker/subtleHashNode.d.ts

@@ -0,0 +1,2 @@
+export declare const subtleHashFunc: () => void;
+//# sourceMappingURL=subtleHashNode.d.ts.map

package/dist/browser/worker/subtleHashNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtleHashNode.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHashNode.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,cAAc,YAU1B,CAAA"}