@xyo-network/hash 4.0.2 → 4.1.0

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

@@ -45,11 +45,26 @@
     }
   });
 
-  // ../../../../../../node_modules/.store/@xylabs-platform-npm-4.12.33-b567d22d1d/package/dist/browser/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-platform-npm-4.13.15-d874cb75fa/package/dist/browser/index.mjs
   var subtle = globalThis.crypto.subtle;
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.12.33-cbb964c08c/package/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.13.15-48ed8b650d/package/dist/browser/worker/worker.browser.mjs
   var import_is_observable_2_1_0 = __toESM(require_package(), 1);
+  var __defProp2 = Object.defineProperty;
+  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+  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);
+      }
+    };
+  }
+  __name(extendSerializer, "extendSerializer");
   var DefaultErrorSerializer = {
     deserialize(message) {
       return Object.assign(new Error(message.message), {
@@ -66,7 +81,7 @@
       };
     }
   };
-  var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var isSerializedError = /* @__PURE__ */ __name((thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error", "isSerializedError");
   var DefaultSerializer = {
     deserialize(message) {
       return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
@@ -76,96 +91,144 @@
     }
   };
   globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function registerSerializer(serializer) {
+    globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
+  }
+  __name(registerSerializer, "registerSerializer");
   function deserialize(message) {
     return globalThis.registeredSerializer.deserialize(message);
   }
+  __name(deserialize, "deserialize");
   function serialize(input) {
     return globalThis.registeredSerializer.serialize(input);
   }
+  __name(serialize, "serialize");
   var $errors = Symbol("thread.errors");
   var $events = Symbol("thread.events");
   var $terminate = Symbol("thread.terminate");
   var $transferable = Symbol("thread.transferable");
   var $worker = Symbol("thread.worker");
+  function isTransferable(thing) {
+    if (!thing || typeof thing !== "object") return false;
+    return true;
+  }
+  __name(isTransferable, "isTransferable");
   function isTransferDescriptor(thing) {
     return thing && typeof thing === "object" && thing[$transferable];
   }
-  var isErrorEvent = (value) => value && value.error;
+  __name(isTransferDescriptor, "isTransferDescriptor");
+  function Transfer(payload, transferables) {
+    console.log("Transfer");
+    if (!transferables) {
+      if (!isTransferable(payload)) throw new Error("Not transferable");
+      transferables = [
+        payload
+      ];
+    }
+    return {
+      [$transferable]: true,
+      send: payload,
+      transferables
+    };
+  }
+  __name(Transfer, "Transfer");
+  var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
+    MasterMessageType2["cancel"] = "cancel";
+    MasterMessageType2["run"] = "run";
+    return MasterMessageType2;
+  }({});
+  var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
+    WorkerMessageType2["error"] = "error";
+    WorkerMessageType2["init"] = "init";
+    WorkerMessageType2["result"] = "result";
+    WorkerMessageType2["running"] = "running";
+    WorkerMessageType2["uncaughtError"] = "uncaughtError";
+    return WorkerMessageType2;
+  }({});
+  var isErrorEvent = /* @__PURE__ */ __name((value) => value && value.error, "isErrorEvent");
   function createExpose(implementation, self2) {
     let exposeCalled = false;
     const activeSubscriptions = /* @__PURE__ */ new Map();
-    const isMasterJobCancelMessage = (thing) => thing && thing.type === "cancel";
-    const isMasterJobRunMessage = (thing) => thing && thing.type === "run";
-    const isObservable = (thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing);
+    const isMasterJobCancelMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.cancel, "isMasterJobCancelMessage");
+    const isMasterJobRunMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.run, "isMasterJobRunMessage");
+    const isObservable = /* @__PURE__ */ __name((thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing), "isObservable");
     function isZenObservable(thing) {
       return thing && typeof thing === "object" && typeof thing.subscribe === "function";
     }
+    __name(isZenObservable, "isZenObservable");
     function deconstructTransfer(thing) {
-      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      return isTransferDescriptor(thing) ? {
+        payload: thing.send,
+        transferables: thing.transferables
+      } : {
+        payload: thing,
+        transferables: void 0
+      };
     }
+    __name(deconstructTransfer, "deconstructTransfer");
     function postFunctionInitMessage() {
       const initMessage = {
-        exposed: { type: "function" },
-        type: "init"
-        /* init */
+        exposed: {
+          type: "function"
+        },
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postFunctionInitMessage, "postFunctionInitMessage");
     function postModuleInitMessage(methodNames) {
       const initMessage = {
         exposed: {
           methods: methodNames,
           type: "module"
         },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postModuleInitMessage, "postModuleInitMessage");
     function postJobErrorMessage(uid, rawError) {
       const { payload: error, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
         error: serialize(error),
-        type: "error",
+        type: WorkerMessageType.error,
         uid
       };
       implementation.postMessageToMaster(errorMessage, transferables);
     }
+    __name(postJobErrorMessage, "postJobErrorMessage");
     function postJobResultMessage(uid, completed, resultValue) {
       const { payload, transferables } = deconstructTransfer(resultValue);
       const resultMessage = {
         complete: completed ? true : void 0,
         payload,
-        type: "result",
+        type: WorkerMessageType.result,
         uid
       };
       implementation.postMessageToMaster(resultMessage, transferables);
     }
+    __name(postJobResultMessage, "postJobResultMessage");
     function postJobStartMessage(uid, resultType) {
       const startMessage = {
         resultType,
-        type: "running",
+        type: WorkerMessageType.running,
         uid
       };
       implementation.postMessageToMaster(startMessage);
     }
+    __name(postJobStartMessage, "postJobStartMessage");
     function postUncaughtErrorMessage(error) {
       try {
         const errorMessage = {
           error: serialize(error),
-          type: "uncaughtError"
-          /* uncaughtError */
+          type: WorkerMessageType.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
-        );
+        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);
       }
     }
+    __name(postUncaughtErrorMessage, "postUncaughtErrorMessage");
     async function runFunction(jobUID, fn, args) {
       let syncResult;
       try {
@@ -177,17 +240,13 @@
       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);
-          }
-        );
+        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 {
@@ -198,7 +257,8 @@
         }
       }
     }
-    const expose2 = (exposed) => {
+    __name(runFunction, "runFunction");
+    const expose2 = /* @__PURE__ */ __name((exposed) => {
       if (!implementation.isWorkerRuntime()) {
         throw new Error("expose() called in the master thread.");
       }
@@ -234,7 +294,7 @@
           }
         }
       });
-    };
+    }, "expose");
     if (typeof globalThis !== "undefined" && typeof self2.addEventListener === "function" && implementation.isWorkerRuntime()) {
       self2.addEventListener("error", (event) => {
         setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
@@ -258,23 +318,24 @@
     }
     return expose2;
   }
-  var isWorkerRuntime = function isWorkerRuntime2() {
+  __name(createExpose, "createExpose");
+  var isWorkerRuntime = /* @__PURE__ */ __name(function isWorkerRuntime2() {
     const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
     return self !== void 0 && self["postMessage"] && !isWindowContext ? true : false;
-  };
-  var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+  }, "isWorkerRuntime");
+  var postMessageToMaster = /* @__PURE__ */ __name(function postMessageToMaster2(data, transferList) {
     self.postMessage(data, transferList);
-  };
-  var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
-    const messageHandler = (messageEvent) => {
+  }, "postMessageToMaster");
+  var subscribeToMasterMessages = /* @__PURE__ */ __name(function subscribeToMasterMessages2(onMessage) {
+    const messageHandler = /* @__PURE__ */ __name((messageEvent) => {
       onMessage(messageEvent.data);
-    };
-    const unsubscribe = () => {
+    }, "messageHandler");
+    const unsubscribe = /* @__PURE__ */ __name(() => {
       self.removeEventListener("message", messageHandler);
-    };
+    }, "unsubscribe");
     self.addEventListener("message", messageHandler);
     return unsubscribe;
-  };
+  }, "subscribeToMasterMessages");
   var addEventListener = self.addEventListener.bind(void 0);
   var postMessage = self.postMessage.bind(void 0);
   var removeEventListener = self.removeEventListener.bind(void 0);

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

@@ -0,0 +1,2 @@
+
+export { };

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

@@ -45,7 +45,7 @@
     }
   });
 
-  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-4.12.33-541f8e1335/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-4.13.15-eb22fb975b/package/dist/neutral/index.mjs
   function isUndefined(value) {
     return value === void 0;
   }
@@ -56,7 +56,7 @@
     return typeof value === "number";
   }
 
-  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.12.33-fe5de23fc3/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.13.15-468ce57811/package/dist/neutral/index.mjs
   var assertError = (value, assert, defaultMessage) => {
     if (!isUndefined(assert)) {
       const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
@@ -112,8 +112,23 @@
     return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
   }
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.12.33-cbb964c08c/package/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.13.15-48ed8b650d/package/dist/browser/worker/worker.browser.mjs
   var import_is_observable_2_1_0 = __toESM(require_package(), 1);
+  var __defProp2 = Object.defineProperty;
+  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+  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);
+      }
+    };
+  }
+  __name(extendSerializer, "extendSerializer");
   var DefaultErrorSerializer = {
     deserialize(message) {
       return Object.assign(new Error(message.message), {
@@ -130,7 +145,7 @@
       };
     }
   };
-  var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var isSerializedError = /* @__PURE__ */ __name((thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error", "isSerializedError");
   var DefaultSerializer = {
     deserialize(message) {
       return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
@@ -140,96 +155,144 @@
     }
   };
   globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function registerSerializer(serializer) {
+    globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
+  }
+  __name(registerSerializer, "registerSerializer");
   function deserialize(message) {
     return globalThis.registeredSerializer.deserialize(message);
   }
+  __name(deserialize, "deserialize");
   function serialize(input) {
     return globalThis.registeredSerializer.serialize(input);
   }
+  __name(serialize, "serialize");
   var $errors = Symbol("thread.errors");
   var $events = Symbol("thread.events");
   var $terminate = Symbol("thread.terminate");
   var $transferable = Symbol("thread.transferable");
   var $worker = Symbol("thread.worker");
+  function isTransferable(thing) {
+    if (!thing || typeof thing !== "object") return false;
+    return true;
+  }
+  __name(isTransferable, "isTransferable");
   function isTransferDescriptor(thing) {
     return thing && typeof thing === "object" && thing[$transferable];
   }
-  var isErrorEvent = (value) => value && value.error;
+  __name(isTransferDescriptor, "isTransferDescriptor");
+  function Transfer(payload, transferables) {
+    console.log("Transfer");
+    if (!transferables) {
+      if (!isTransferable(payload)) throw new Error("Not transferable");
+      transferables = [
+        payload
+      ];
+    }
+    return {
+      [$transferable]: true,
+      send: payload,
+      transferables
+    };
+  }
+  __name(Transfer, "Transfer");
+  var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
+    MasterMessageType2["cancel"] = "cancel";
+    MasterMessageType2["run"] = "run";
+    return MasterMessageType2;
+  }({});
+  var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
+    WorkerMessageType2["error"] = "error";
+    WorkerMessageType2["init"] = "init";
+    WorkerMessageType2["result"] = "result";
+    WorkerMessageType2["running"] = "running";
+    WorkerMessageType2["uncaughtError"] = "uncaughtError";
+    return WorkerMessageType2;
+  }({});
+  var isErrorEvent = /* @__PURE__ */ __name((value) => value && value.error, "isErrorEvent");
   function createExpose(implementation, self2) {
     let exposeCalled = false;
     const activeSubscriptions = /* @__PURE__ */ new Map();
-    const isMasterJobCancelMessage = (thing) => thing && thing.type === "cancel";
-    const isMasterJobRunMessage = (thing) => thing && thing.type === "run";
-    const isObservable = (thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing);
+    const isMasterJobCancelMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.cancel, "isMasterJobCancelMessage");
+    const isMasterJobRunMessage = /* @__PURE__ */ __name((thing) => thing && thing.type === MasterMessageType.run, "isMasterJobRunMessage");
+    const isObservable = /* @__PURE__ */ __name((thing) => (0, import_is_observable_2_1_0.default)(thing) || isZenObservable(thing), "isObservable");
     function isZenObservable(thing) {
       return thing && typeof thing === "object" && typeof thing.subscribe === "function";
     }
+    __name(isZenObservable, "isZenObservable");
     function deconstructTransfer(thing) {
-      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      return isTransferDescriptor(thing) ? {
+        payload: thing.send,
+        transferables: thing.transferables
+      } : {
+        payload: thing,
+        transferables: void 0
+      };
     }
+    __name(deconstructTransfer, "deconstructTransfer");
     function postFunctionInitMessage() {
       const initMessage = {
-        exposed: { type: "function" },
-        type: "init"
-        /* init */
+        exposed: {
+          type: "function"
+        },
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postFunctionInitMessage, "postFunctionInitMessage");
     function postModuleInitMessage(methodNames) {
       const initMessage = {
         exposed: {
           methods: methodNames,
           type: "module"
         },
-        type: "init"
-        /* init */
+        type: WorkerMessageType.init
       };
       implementation.postMessageToMaster(initMessage);
     }
+    __name(postModuleInitMessage, "postModuleInitMessage");
     function postJobErrorMessage(uid, rawError) {
       const { payload: error, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
         error: serialize(error),
-        type: "error",
+        type: WorkerMessageType.error,
         uid
       };
       implementation.postMessageToMaster(errorMessage, transferables);
     }
+    __name(postJobErrorMessage, "postJobErrorMessage");
     function postJobResultMessage(uid, completed, resultValue) {
       const { payload, transferables } = deconstructTransfer(resultValue);
       const resultMessage = {
         complete: completed ? true : void 0,
         payload,
-        type: "result",
+        type: WorkerMessageType.result,
         uid
       };
       implementation.postMessageToMaster(resultMessage, transferables);
     }
+    __name(postJobResultMessage, "postJobResultMessage");
     function postJobStartMessage(uid, resultType) {
       const startMessage = {
         resultType,
-        type: "running",
+        type: WorkerMessageType.running,
         uid
       };
       implementation.postMessageToMaster(startMessage);
     }
+    __name(postJobStartMessage, "postJobStartMessage");
     function postUncaughtErrorMessage(error) {
       try {
         const errorMessage = {
           error: serialize(error),
-          type: "uncaughtError"
-          /* uncaughtError */
+          type: WorkerMessageType.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
-        );
+        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);
       }
     }
+    __name(postUncaughtErrorMessage, "postUncaughtErrorMessage");
     async function runFunction(jobUID, fn, args) {
       let syncResult;
       try {
@@ -241,17 +304,13 @@
       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);
-          }
-        );
+        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 {
@@ -262,7 +321,8 @@
         }
       }
     }
-    const expose2 = (exposed) => {
+    __name(runFunction, "runFunction");
+    const expose2 = /* @__PURE__ */ __name((exposed) => {
       if (!implementation.isWorkerRuntime()) {
         throw new Error("expose() called in the master thread.");
       }
@@ -298,7 +358,7 @@
           }
         }
       });
-    };
+    }, "expose");
     if (typeof globalThis !== "undefined" && typeof self2.addEventListener === "function" && implementation.isWorkerRuntime()) {
       self2.addEventListener("error", (event) => {
         setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
@@ -322,23 +382,24 @@
     }
     return expose2;
   }
-  var isWorkerRuntime = function isWorkerRuntime2() {
+  __name(createExpose, "createExpose");
+  var isWorkerRuntime = /* @__PURE__ */ __name(function isWorkerRuntime2() {
     const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
     return self !== void 0 && self["postMessage"] && !isWindowContext ? true : false;
-  };
-  var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+  }, "isWorkerRuntime");
+  var postMessageToMaster = /* @__PURE__ */ __name(function postMessageToMaster2(data, transferList) {
     self.postMessage(data, transferList);
-  };
-  var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
-    const messageHandler = (messageEvent) => {
+  }, "postMessageToMaster");
+  var subscribeToMasterMessages = /* @__PURE__ */ __name(function subscribeToMasterMessages2(onMessage) {
+    const messageHandler = /* @__PURE__ */ __name((messageEvent) => {
       onMessage(messageEvent.data);
-    };
-    const unsubscribe = () => {
+    }, "messageHandler");
+    const unsubscribe = /* @__PURE__ */ __name(() => {
       self.removeEventListener("message", messageHandler);
-    };
+    }, "unsubscribe");
     self.addEventListener("message", messageHandler);
     return unsubscribe;
-  };
+  }, "subscribeToMasterMessages");
   var addEventListener = self.addEventListener.bind(void 0);
   var postMessage = self.postMessage.bind(void 0);
   var removeEventListener = self.removeEventListener.bind(void 0);

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

@@ -0,0 +1,2 @@
+
+export { };

package/dist/neutral/index.d.ts

@@ -0,0 +1,87 @@
+import { EmptyObject, ObjectWrapper } from '@xylabs/object';
+import * as _xylabs_threads_master from '@xylabs/threads/master';
+import { Worker } from '@xylabs/threads/master';
+import { Hash } from '@xylabs/hex';
+import { WasmSupport } from '@xyo-network/wasm';
+
+declare const hasEmptyFields: <T extends EmptyObject>(obj: T) => boolean;
+
+declare global {
+    var xyo: {
+        hashing?: ObjectHasher;
+    };
+}
+
+declare class ObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectWrapper<T> {
+    static allowHashPooling: boolean;
+    static allowSubtle: boolean;
+    static createBrowserWorker?: (url?: URL) => Worker | undefined;
+    static createNodeWorker?: (func?: () => unknown) => Worker | undefined;
+    static readonly initialized: void;
+    static readonly subtleHashWorkerUrl?: URL;
+    static warnIfUsingJsHash: boolean;
+    static readonly wasmHashWorkerUrl?: URL;
+    static readonly wasmInitialized: Promise<void>;
+    static readonly wasmSupport: WasmSupport;
+    private static _subtleHashPool?;
+    private static _wasmHashPool?;
+    private static get subtleHashPool();
+    private static get wasmHashPool();
+    static createWorker(url?: URL, func?: () => unknown): Worker;
+    static filterExcludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static findByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash): Promise<T | undefined>;
+    /**
+     * Asynchronously hashes a payload
+     * @param obj A payload
+     * @returns The payload hash
+     */
+    static hash<T extends EmptyObject>(obj: T): Promise<Hash>;
+    static hashBytes(bytes: ArrayBuffer | Uint8Array): Promise<Hash>;
+    static hashFields<T extends EmptyObject>(obj: T): T;
+    /**
+     * Creates an array of payload/hash tuples based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload/hash tuples
+     */
+    static hashPairs<T extends EmptyObject>(objs: T[]): Promise<[T, Hash][]>;
+    /**
+     * Creates an array of payload hashes based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload hashes
+     */
+    static hashes<T extends EmptyObject>(objs?: T[]): Promise<Hash[] | undefined>;
+    /**
+     * Returns a clone of the payload that is JSON safe
+     * @param obj A payload
+     * @param meta Keeps underscore (meta) fields if set to true
+     * @returns Returns a clone of the payload that is JSON safe
+     */
+    static json<T extends EmptyObject>(payload: T, meta?: boolean): T;
+    /** @deprecated us json instead */
+    static jsonPayload<T extends EmptyObject>(payload: T, meta?: boolean): T;
+    static stringifyHashFields<T extends EmptyObject>(obj: T): string;
+    static subtleHash(data: Uint8Array): Promise<ArrayBuffer>;
+    static wasmHash(data: Uint8Array): Promise<Hash>;
+    private static createWorkerPool;
+    hash(): Promise<Hash>;
+    /**
+     * Returns a clone of the payload that is JSON safe
+     * @param meta Keeps underscore (meta) fields if set to true
+     * @returns Returns a clone of the payload that is JSON safe
+     */
+    json(meta?: boolean): T;
+}
+
+declare class NodeObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
+    static readonly createNodeWorker: (func?: () => unknown) => _xylabs_threads_master.Worker;
+}
+/** @deprecated use NodeObjectHasher instead */
+declare class NodePayloadHasher<T extends EmptyObject = EmptyObject> extends NodeObjectHasher<T> {
+}
+
+declare const removeEmptyFields: <T extends EmptyObject>(obj: T) => T;
+
+declare const sortFields: <T extends EmptyObject>(obj: T) => T;
+
+export { NodeObjectHasher as ObjectHasher, NodePayloadHasher as PayloadHasher, hasEmptyFields, removeEmptyFields, sortFields };