@xyo-network/hash 7.0.11 → 7.0.13

package/dist/node/worker/subtleHash-bundle.mjs

@@ -0,0 +1,361 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
+  };
+  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);
+
+  // ../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_649172f6a3c2e5736d1bf5bb5ca2adbf/node_modules/@ariestools/sdk/dist/browser/platform.mjs
+  var isBrowser, isWebworker, isNode;
+  var init_platform = __esm({
+    "../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_649172f6a3c2e5736d1bf5bb5ca2adbf/node_modules/@ariestools/sdk/dist/browser/platform.mjs"() {
+      isBrowser = () => {
+        return !isWebworker() && globalThis.constructor?.name === "Window";
+      };
+      isWebworker = () => {
+        return typeof globalThis === "object" && globalThis.constructor?.name === "DedicatedWorkerGlobalScope";
+      };
+      isNode = () => {
+        return false;
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/.pnpm/@xylabs+platform@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@op_2a5110b456b33147d01e80609f7c81d5/node_modules/@xylabs/platform/dist/neutral/index.mjs
+  var neutral_exports = {};
+  __export(neutral_exports, {
+    isBrowser: () => isBrowser,
+    isNode: () => isNode,
+    isWebworker: () => isWebworker
+  });
+  var init_neutral = __esm({
+    "../../../../../../node_modules/.pnpm/@xylabs+platform@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@op_2a5110b456b33147d01e80609f7c81d5/node_modules/@xylabs/platform/dist/neutral/index.mjs"() {
+      init_platform();
+    }
+  });
+
+  // ../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_a1685075a98125ef0b6f31620ba50469/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs
+  var worker_browser_exports = {};
+  __export(worker_browser_exports, {
+    Transfer: () => Transfer,
+    addEventListener: () => addEventListener,
+    expose: () => expose,
+    isWorkerRuntime: () => isWorkerRuntime,
+    postMessage: () => postMessage,
+    postMessageToMaster: () => postMessageToMaster,
+    registerSerializer: () => registerSerializer,
+    removeEventListener: () => removeEventListener,
+    subscribeToMasterMessages: () => subscribeToMasterMessages
+  });
+  function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+      deserialize: (message) => implementation.deserialize(message, fallbackDeserializer),
+      serialize: (input) => implementation.serialize(input, fallbackSerializer)
+    };
+  }
+  function registerSerializer(serializer) {
+    globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
+  }
+  function deserialize(message) {
+    return globalThis.registeredSerializer.deserialize(message);
+  }
+  function serialize(input) {
+    return globalThis.registeredSerializer.serialize(input);
+  }
+  function isTransferable(thing) {
+    if (thing == null || typeof thing !== "object") return false;
+    return true;
+  }
+  function isTransferDescriptor(thing) {
+    return thing != null && typeof thing === "object" && Reflect.get(thing, $transferable) === true;
+  }
+  function Transfer(payload, transferables) {
+    console.log("Transfer");
+    if (!transferables) {
+      if (!isTransferable(payload)) throw new Error("Not transferable");
+      transferables = [payload];
+    }
+    const descriptor = {
+      send: payload,
+      transferables
+    };
+    Object.defineProperty(descriptor, $transferable, { value: true });
+    return descriptor;
+  }
+  function createExpose(implementation, self2) {
+    let exposeCalled = false;
+    const activeSubscriptions = /* @__PURE__ */ new Map();
+    const isMasterJobCancelMessage = (thing) => thing?.type === "cancel";
+    const isMasterJobRunMessage = (thing) => thing?.type === "run";
+    const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
+    function isZenObservable(thing) {
+      return thing != null && typeof thing === "object" && typeof thing.subscribe === "function";
+    }
+    function deconstructTransfer(thing) {
+      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+    }
+    function postFunctionInitMessage() {
+      const initMessage = {
+        exposed: { type: "function" },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postModuleInitMessage(methodNames) {
+      const initMessage = {
+        exposed: {
+          methods: methodNames,
+          type: "module"
+        },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postJobErrorMessage(uid, rawError) {
+      const { payload: error, transferables } = deconstructTransfer(rawError);
+      const errorMessage = {
+        error: serialize(error),
+        type: "error",
+        uid
+      };
+      implementation.postMessageToMaster(errorMessage, transferables);
+    }
+    function postJobResultMessage(uid, completed, resultValue) {
+      const { payload, transferables } = deconstructTransfer(resultValue);
+      const resultMessage = {
+        complete: completed ? true : void 0,
+        payload,
+        type: "result",
+        uid
+      };
+      implementation.postMessageToMaster(resultMessage, transferables);
+    }
+    function postJobStartMessage(uid, resultType) {
+      const startMessage = {
+        resultType,
+        type: "running",
+        uid
+      };
+      implementation.postMessageToMaster(startMessage);
+    }
+    function postUncaughtErrorMessage(error) {
+      try {
+        const errorMessage = {
+          error: serialize(error),
+          type: "uncaughtError"
+          /* uncaughtError */
+        };
+        implementation.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
+        );
+      }
+    }
+    async function runFunction(jobUID, fn, args) {
+      let syncResult;
+      try {
+        syncResult = fn(...args);
+      } catch (ex) {
+        const error = ex;
+        return postJobErrorMessage(jobUID, error);
+      }
+      const resultType = isObservable(syncResult) ? "observable" : "promise";
+      postJobStartMessage(jobUID, resultType);
+      if (isObservable(syncResult)) {
+        const subscription = syncResult.subscribe(
+          (value) => postJobResultMessage(jobUID, false, serialize(value)),
+          (error) => {
+            postJobErrorMessage(jobUID, serialize(error));
+            activeSubscriptions.delete(jobUID);
+          },
+          () => {
+            postJobResultMessage(jobUID, true);
+            activeSubscriptions.delete(jobUID);
+          }
+        );
+        activeSubscriptions.set(jobUID, subscription);
+      } else {
+        try {
+          const result = await syncResult;
+          postJobResultMessage(jobUID, true, serialize(result));
+        } catch (error) {
+          postJobErrorMessage(jobUID, serialize(error));
+        }
+      }
+    }
+    const expose2 = (exposed) => {
+      if (!implementation.isWorkerRuntime()) {
+        throw new Error("expose() called in the master thread.");
+      }
+      if (exposeCalled) {
+        throw new 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.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method === void 0) {
+            runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+          }
+        });
+        postFunctionInitMessage();
+      } else if (typeof exposed === "object" && exposed !== null) {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method !== void 0) {
+            runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+          }
+        });
+        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === "function");
+        postModuleInitMessage(methodNames);
+      } else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+      }
+      implementation.subscribeToMasterMessages((messageData) => {
+        if (!isMasterJobCancelMessage(messageData)) {
+          return;
+        }
+        const jobUID = messageData.uid;
+        const subscription = activeSubscriptions.get(jobUID);
+        if (subscription) {
+          subscription.unsubscribe();
+          activeSubscriptions.delete(jobUID);
+        }
+      });
+    };
+    const subscribeToBrowserUncaughtErrors = () => {
+      if (typeof globalThis === "undefined" || typeof self2.addEventListener !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      self2.addEventListener("error", (event) => {
+        setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
+      });
+      self2.addEventListener("unhandledrejection", (event) => {
+        const error = event.reason;
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    const subscribeToNodeUncaughtErrors = () => {
+      const nodeProcess = globalThis.process;
+      if (nodeProcess === void 0 || typeof nodeProcess.on !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      nodeProcess.on("uncaughtException", (error) => {
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+      });
+      nodeProcess.on("unhandledRejection", (error) => {
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    subscribeToBrowserUncaughtErrors();
+    subscribeToNodeUncaughtErrors();
+    return expose2;
+  }
+  var DefaultErrorSerializer, isSerializedError, DefaultSerializer, isSomeObservable, $transferable, isErrorEvent, isWorkerRuntime, postMessageToMaster, subscribeToMasterMessages, addEventListener, postMessage, removeEventListener, expose;
+  var init_worker_browser = __esm({
+    "../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_a1685075a98125ef0b6f31620ba50469/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs"() {
+      DefaultErrorSerializer = {
+        deserialize: (message) => {
+          const error = Object.create(Error.prototype);
+          error.message = message.message;
+          error.name = message.name;
+          error.stack = message.stack;
+          return error;
+        },
+        serialize: (error) => ({
+          __error_marker: "$$error",
+          message: error.message,
+          name: error.name,
+          stack: error.stack
+        })
+      };
+      isSerializedError = (thing) => thing != null && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+      DefaultSerializer = {
+        deserialize: (message) => isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message,
+        serialize: (input) => input instanceof Error ? DefaultErrorSerializer.serialize(input) : input
+      };
+      globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+      isSomeObservable = (value) => {
+        if (value == null) {
+          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;
+      };
+      $transferable = /* @__PURE__ */ Symbol("thread.transferable");
+      isErrorEvent = (value) => value !== void 0 && value.error !== void 0;
+      isWorkerRuntime = function isWorkerRuntime2() {
+        const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
+        return self?.postMessage !== void 0 && !isWindowContext;
+      };
+      postMessageToMaster = function postMessageToMaster2(data, transferList) {
+        self.postMessage(data, transferList);
+      };
+      subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
+        const messageHandler = (messageEvent) => {
+          onMessage(messageEvent.data);
+        };
+        const unsubscribe = () => {
+          self.removeEventListener("message", messageHandler);
+        };
+        self.addEventListener("message", messageHandler);
+        return unsubscribe;
+      };
+      addEventListener = self.addEventListener.bind(void 0);
+      postMessage = self.postMessage.bind(void 0);
+      removeEventListener = self.removeEventListener.bind(void 0);
+      expose = createExpose({
+        isWorkerRuntime,
+        postMessageToMaster,
+        subscribeToMasterMessages
+      }, {
+        addEventListener,
+        postMessage,
+        removeEventListener
+      });
+    }
+  });
+
+  // src/worker/subtleHashNode.ts
+  var subtleHashFunc = () => {
+    const { subtle } = (init_neutral(), __toCommonJS(neutral_exports));
+    const { expose: expose2 } = (init_worker_browser(), __toCommonJS(worker_browser_exports));
+    expose2({ hash: async (data) => await subtle.digest("SHA-256", data) });
+  };
+})();

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subtleHash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subtleHash.d.ts","sourceRoot":"","sources":["../../../src/worker/subtleHash.ts"],"names":[],"mappings":""}

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

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

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

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