@xyo-network/hash 3.9.38 → 3.10.0

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

@@ -6,7 +6,6 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -26,2596 +25,9 @@
     isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
-  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/serializers.js
-  var require_serializers = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/serializers.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.DefaultSerializer = void 0;
-      exports.extendSerializer = extendSerializer;
-      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);
-          }
-        };
-      }
-      var DefaultErrorSerializer = {
-        deserialize(message) {
-          return Object.assign(new 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) {
-          return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
-        },
-        serialize(input) {
-          return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
-        }
-      };
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/common.js
-  var require_common = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/common.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.registerSerializer = registerSerializer;
-      exports.deserialize = deserialize;
-      exports.serialize = serialize;
-      var serializers_1 = require_serializers();
-      var registeredSerializer = serializers_1.DefaultSerializer;
-      function registerSerializer(serializer) {
-        registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
-      }
-      function deserialize(message) {
-        return registeredSerializer.deserialize(message);
-      }
-      function serialize(input) {
-        return registeredSerializer.serialize(input);
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/get-bundle-url.browser.js
-  var require_get_bundle_url_browser = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/get-bundle-url.browser.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getBundleURL = getBundleURLCached;
-      var bundleURL;
-      function getBundleURLCached() {
-        if (!bundleURL) {
-          bundleURL = getBundleURL();
-        }
-        return bundleURL;
-      }
-      function getBundleURL() {
-        try {
-          throw new Error("getBundleURL failed");
-        } catch (err) {
-          const matches = ("" + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^\n)]+/g);
-          if (matches) {
-            return getBaseURL(matches[0]);
-          }
-        }
-        return "/";
-      }
-      function getBaseURL(url) {
-        return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, "$1") + "/";
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/implementation.browser.js
-  var require_implementation_browser = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/implementation.browser.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.defaultPoolSize = void 0;
-      exports.getWorkerImplementation = getWorkerImplementation;
-      exports.isWorkerRuntime = isWorkerRuntime;
-      var get_bundle_url_browser_1 = require_get_bundle_url_browser();
-      exports.defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
-      var isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
-      function createSourceBlobURL(code) {
-        const blob = new Blob([code], { type: "application/javascript" });
-        return URL.createObjectURL(blob);
-      }
-      function selectWorkerImplementation() {
-        if (typeof Worker === "undefined") {
-          return class NoWebWorker {
-            constructor() {
-              throw new Error("No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.");
-            }
-          };
-        }
-        class WebWorker extends Worker {
-          constructor(url, options) {
-            if (typeof url === "string" && options && options._baseURL) {
-              url = new URL(url, options._baseURL);
-            } else if (typeof url === "string" && !isAbsoluteURL(url) && /^file:\/\//i.test((0, get_bundle_url_browser_1.getBundleURL)())) {
-              url = new URL(url, (0, get_bundle_url_browser_1.getBundleURL)().replace(/\/[^/]+$/, "/"));
-              if (options?.CORSWorkaround ?? true) {
-                url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
-              }
-            }
-            if (typeof url === "string" && isAbsoluteURL(url) && (options?.CORSWorkaround ?? true)) {
-              url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
-            }
-            super(url, options);
-          }
-        }
-        class BlobWorker extends WebWorker {
-          constructor(blob, options) {
-            const url = globalThis.URL.createObjectURL(blob);
-            super(url, options);
-          }
-          static fromText(source, options) {
-            const blob = new globalThis.Blob([source], { type: "text/javascript" });
-            return new BlobWorker(blob, options);
-          }
-        }
-        return {
-          blob: BlobWorker,
-          default: WebWorker
-        };
-      }
-      var implementation;
-      function getWorkerImplementation() {
-        if (!implementation) {
-          implementation = selectWorkerImplementation();
-        }
-        return implementation;
-      }
-      function isWorkerRuntime() {
-        const isWindowContext = typeof globalThis !== "undefined" && typeof Window !== "undefined" && globalThis instanceof Window;
-        return typeof globalThis !== "undefined" && self["postMessage"] && !isWindowContext ? true : false;
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/ms-npm-2.1.3-81ff3cfac1/package/index.js
-  var require_package = __commonJS({
-    "../../../../../../node_modules/.store/ms-npm-2.1.3-81ff3cfac1/package/index.js"(exports, module) {
-      var s = 1e3;
-      var m = s * 60;
-      var h = m * 60;
-      var d = h * 24;
-      var w = d * 7;
-      var y = d * 365.25;
-      module.exports = function(val, options) {
-        options = options || {};
-        var type = typeof val;
-        if (type === "string" && val.length > 0) {
-          return parse(val);
-        } else if (type === "number" && isFinite(val)) {
-          return options.long ? fmtLong(val) : fmtShort(val);
-        }
-        throw new Error(
-          "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
-        );
-      };
-      function parse(str) {
-        str = String(str);
-        if (str.length > 100) {
-          return;
-        }
-        var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-          str
-        );
-        if (!match) {
-          return;
-        }
-        var n = parseFloat(match[1]);
-        var type = (match[2] || "ms").toLowerCase();
-        switch (type) {
-          case "years":
-          case "year":
-          case "yrs":
-          case "yr":
-          case "y":
-            return n * y;
-          case "weeks":
-          case "week":
-          case "w":
-            return n * w;
-          case "days":
-          case "day":
-          case "d":
-            return n * d;
-          case "hours":
-          case "hour":
-          case "hrs":
-          case "hr":
-          case "h":
-            return n * h;
-          case "minutes":
-          case "minute":
-          case "mins":
-          case "min":
-          case "m":
-            return n * m;
-          case "seconds":
-          case "second":
-          case "secs":
-          case "sec":
-          case "s":
-            return n * s;
-          case "milliseconds":
-          case "millisecond":
-          case "msecs":
-          case "msec":
-          case "ms":
-            return n;
-          default:
-            return void 0;
-        }
-      }
-      function fmtShort(ms) {
-        var msAbs = Math.abs(ms);
-        if (msAbs >= d) {
-          return Math.round(ms / d) + "d";
-        }
-        if (msAbs >= h) {
-          return Math.round(ms / h) + "h";
-        }
-        if (msAbs >= m) {
-          return Math.round(ms / m) + "m";
-        }
-        if (msAbs >= s) {
-          return Math.round(ms / s) + "s";
-        }
-        return ms + "ms";
-      }
-      function fmtLong(ms) {
-        var msAbs = Math.abs(ms);
-        if (msAbs >= d) {
-          return plural(ms, msAbs, d, "day");
-        }
-        if (msAbs >= h) {
-          return plural(ms, msAbs, h, "hour");
-        }
-        if (msAbs >= m) {
-          return plural(ms, msAbs, m, "minute");
-        }
-        if (msAbs >= s) {
-          return plural(ms, msAbs, s, "second");
-        }
-        return ms + " ms";
-      }
-      function plural(ms, msAbs, n, name) {
-        var isPlural = msAbs >= n * 1.5;
-        return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/debug-virtual-ec9ff5b796/package/src/common.js
-  var require_common2 = __commonJS({
-    "../../../../../../node_modules/.store/debug-virtual-ec9ff5b796/package/src/common.js"(exports, module) {
-      function setup(env) {
-        createDebug.debug = createDebug;
-        createDebug.default = createDebug;
-        createDebug.coerce = coerce;
-        createDebug.disable = disable;
-        createDebug.enable = enable;
-        createDebug.enabled = enabled;
-        createDebug.humanize = require_package();
-        createDebug.destroy = destroy;
-        Object.keys(env).forEach((key) => {
-          createDebug[key] = env[key];
-        });
-        createDebug.names = [];
-        createDebug.skips = [];
-        createDebug.formatters = {};
-        function selectColor(namespace) {
-          let hash = 0;
-          for (let i = 0; i < namespace.length; i++) {
-            hash = (hash << 5) - hash + namespace.charCodeAt(i);
-            hash |= 0;
-          }
-          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
-        }
-        createDebug.selectColor = selectColor;
-        function createDebug(namespace) {
-          let prevTime;
-          let enableOverride = null;
-          let namespacesCache;
-          let enabledCache;
-          function debug(...args) {
-            if (!debug.enabled) {
-              return;
-            }
-            const self2 = debug;
-            const curr = Number(/* @__PURE__ */ new Date());
-            const ms = curr - (prevTime || curr);
-            self2.diff = ms;
-            self2.prev = prevTime;
-            self2.curr = curr;
-            prevTime = curr;
-            args[0] = createDebug.coerce(args[0]);
-            if (typeof args[0] !== "string") {
-              args.unshift("%O");
-            }
-            let index = 0;
-            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-              if (match === "%%") {
-                return "%";
-              }
-              index++;
-              const formatter = createDebug.formatters[format];
-              if (typeof formatter === "function") {
-                const val = args[index];
-                match = formatter.call(self2, val);
-                args.splice(index, 1);
-                index--;
-              }
-              return match;
-            });
-            createDebug.formatArgs.call(self2, args);
-            const logFn = self2.log || createDebug.log;
-            logFn.apply(self2, args);
-          }
-          debug.namespace = namespace;
-          debug.useColors = createDebug.useColors();
-          debug.color = createDebug.selectColor(namespace);
-          debug.extend = extend;
-          debug.destroy = createDebug.destroy;
-          Object.defineProperty(debug, "enabled", {
-            enumerable: true,
-            configurable: false,
-            get: () => {
-              if (enableOverride !== null) {
-                return enableOverride;
-              }
-              if (namespacesCache !== createDebug.namespaces) {
-                namespacesCache = createDebug.namespaces;
-                enabledCache = createDebug.enabled(namespace);
-              }
-              return enabledCache;
-            },
-            set: (v) => {
-              enableOverride = v;
-            }
-          });
-          if (typeof createDebug.init === "function") {
-            createDebug.init(debug);
-          }
-          return debug;
-        }
-        function extend(namespace, delimiter) {
-          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
-          newDebug.log = this.log;
-          return newDebug;
-        }
-        function enable(namespaces) {
-          createDebug.save(namespaces);
-          createDebug.namespaces = namespaces;
-          createDebug.names = [];
-          createDebug.skips = [];
-          const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
-          for (const ns of split) {
-            if (ns[0] === "-") {
-              createDebug.skips.push(ns.slice(1));
-            } else {
-              createDebug.names.push(ns);
-            }
-          }
-        }
-        function matchesTemplate(search, template) {
-          let searchIndex = 0;
-          let templateIndex = 0;
-          let starIndex = -1;
-          let matchIndex = 0;
-          while (searchIndex < search.length) {
-            if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
-              if (template[templateIndex] === "*") {
-                starIndex = templateIndex;
-                matchIndex = searchIndex;
-                templateIndex++;
-              } else {
-                searchIndex++;
-                templateIndex++;
-              }
-            } else if (starIndex !== -1) {
-              templateIndex = starIndex + 1;
-              matchIndex++;
-              searchIndex = matchIndex;
-            } else {
-              return false;
-            }
-          }
-          while (templateIndex < template.length && template[templateIndex] === "*") {
-            templateIndex++;
-          }
-          return templateIndex === template.length;
-        }
-        function disable() {
-          const namespaces = [
-            ...createDebug.names,
-            ...createDebug.skips.map((namespace) => "-" + namespace)
-          ].join(",");
-          createDebug.enable("");
-          return namespaces;
-        }
-        function enabled(name) {
-          for (const skip of createDebug.skips) {
-            if (matchesTemplate(name, skip)) {
-              return false;
-            }
-          }
-          for (const ns of createDebug.names) {
-            if (matchesTemplate(name, ns)) {
-              return true;
-            }
-          }
-          return false;
-        }
-        function coerce(val) {
-          if (val instanceof Error) {
-            return val.stack || val.message;
-          }
-          return val;
-        }
-        function destroy() {
-          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-        }
-        createDebug.enable(createDebug.load());
-        return createDebug;
-      }
-      module.exports = setup;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/debug-virtual-ec9ff5b796/package/src/browser.js
-  var require_browser = __commonJS({
-    "../../../../../../node_modules/.store/debug-virtual-ec9ff5b796/package/src/browser.js"(exports, module) {
-      exports.formatArgs = formatArgs;
-      exports.save = save;
-      exports.load = load;
-      exports.useColors = useColors;
-      exports.storage = localstorage();
-      exports.destroy = /* @__PURE__ */ (() => {
-        let warned = false;
-        return () => {
-          if (!warned) {
-            warned = true;
-            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-          }
-        };
-      })();
-      exports.colors = [
-        "#0000CC",
-        "#0000FF",
-        "#0033CC",
-        "#0033FF",
-        "#0066CC",
-        "#0066FF",
-        "#0099CC",
-        "#0099FF",
-        "#00CC00",
-        "#00CC33",
-        "#00CC66",
-        "#00CC99",
-        "#00CCCC",
-        "#00CCFF",
-        "#3300CC",
-        "#3300FF",
-        "#3333CC",
-        "#3333FF",
-        "#3366CC",
-        "#3366FF",
-        "#3399CC",
-        "#3399FF",
-        "#33CC00",
-        "#33CC33",
-        "#33CC66",
-        "#33CC99",
-        "#33CCCC",
-        "#33CCFF",
-        "#6600CC",
-        "#6600FF",
-        "#6633CC",
-        "#6633FF",
-        "#66CC00",
-        "#66CC33",
-        "#9900CC",
-        "#9900FF",
-        "#9933CC",
-        "#9933FF",
-        "#99CC00",
-        "#99CC33",
-        "#CC0000",
-        "#CC0033",
-        "#CC0066",
-        "#CC0099",
-        "#CC00CC",
-        "#CC00FF",
-        "#CC3300",
-        "#CC3333",
-        "#CC3366",
-        "#CC3399",
-        "#CC33CC",
-        "#CC33FF",
-        "#CC6600",
-        "#CC6633",
-        "#CC9900",
-        "#CC9933",
-        "#CCCC00",
-        "#CCCC33",
-        "#FF0000",
-        "#FF0033",
-        "#FF0066",
-        "#FF0099",
-        "#FF00CC",
-        "#FF00FF",
-        "#FF3300",
-        "#FF3333",
-        "#FF3366",
-        "#FF3399",
-        "#FF33CC",
-        "#FF33FF",
-        "#FF6600",
-        "#FF6633",
-        "#FF9900",
-        "#FF9933",
-        "#FFCC00",
-        "#FFCC33"
-      ];
-      function useColors() {
-        if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
-          return true;
-        }
-        if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-          return false;
-        }
-        let m;
-        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
-        typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
-        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-        typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
-        typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
-      }
-      function formatArgs(args) {
-        args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
-        if (!this.useColors) {
-          return;
-        }
-        const c = "color: " + this.color;
-        args.splice(1, 0, c, "color: inherit");
-        let index = 0;
-        let lastC = 0;
-        args[0].replace(/%[a-zA-Z%]/g, (match) => {
-          if (match === "%%") {
-            return;
-          }
-          index++;
-          if (match === "%c") {
-            lastC = index;
-          }
-        });
-        args.splice(lastC, 0, c);
-      }
-      exports.log = console.debug || console.log || (() => {
-      });
-      function save(namespaces) {
-        try {
-          if (namespaces) {
-            exports.storage.setItem("debug", namespaces);
-          } else {
-            exports.storage.removeItem("debug");
-          }
-        } catch (error) {
-        }
-      }
-      function load() {
-        let r;
-        try {
-          r = exports.storage.getItem("debug");
-        } catch (error) {
-        }
-        if (!r && typeof process !== "undefined" && "env" in process) {
-          r = process.env.DEBUG;
-        }
-        return r;
-      }
-      function localstorage() {
-        try {
-          return localStorage;
-        } catch (error) {
-        }
-      }
-      module.exports = require_common2()(exports);
-      var { formatters } = module.exports;
-      formatters.j = function(v) {
-        try {
-          return JSON.stringify(v);
-        } catch (error) {
-          return "[UnexpectedJSONParseError]: " + error.message;
-        }
-      };
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_scheduler.js
-  var require_scheduler = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_scheduler.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());
-        });
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.AsyncSerialScheduler = void 0;
-      var AsyncSerialScheduler = class {
-        constructor(observer) {
-          this._baseObserver = observer;
-          this._pendingPromises = /* @__PURE__ */ new Set();
-        }
-        complete() {
-          Promise.all(this._pendingPromises).then(() => this._baseObserver.complete()).catch((error) => this._baseObserver.error(error));
-        }
-        error(error) {
-          this._baseObserver.error(error);
-        }
-        schedule(task) {
-          const prevPromisesCompletion = Promise.all(this._pendingPromises);
-          const values = [];
-          const next = (value) => values.push(value);
-          const promise = Promise.resolve().then(() => __awaiter2(this, void 0, void 0, function* () {
-            yield prevPromisesCompletion;
-            yield task(next);
-            this._pendingPromises.delete(promise);
-            for (const value of values) {
-              this._baseObserver.next(value);
-            }
-          })).catch((error) => {
-            this._pendingPromises.delete(promise);
-            this._baseObserver.error(error);
-          });
-          this._pendingPromises.add(promise);
-        }
-      };
-      exports.AsyncSerialScheduler = AsyncSerialScheduler;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/symbols.js
-  var require_symbols = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/symbols.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_symbols.js
-  var require_symbols2 = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_symbols.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.registerObservableSymbol = exports.getSymbol = exports.hasSymbol = exports.hasSymbols = void 0;
-      var hasSymbols = () => typeof Symbol === "function";
-      exports.hasSymbols = hasSymbols;
-      var hasSymbol = (name) => exports.hasSymbols() && Boolean(Symbol[name]);
-      exports.hasSymbol = hasSymbol;
-      var getSymbol = (name) => exports.hasSymbol(name) ? Symbol[name] : "@@" + name;
-      exports.getSymbol = getSymbol;
-      function registerObservableSymbol() {
-        if (exports.hasSymbols() && !exports.hasSymbol("observable")) {
-          Symbol.observable = Symbol("observable");
-        }
-      }
-      exports.registerObservableSymbol = registerObservableSymbol;
-      if (!exports.hasSymbol("asyncIterator")) {
-        Symbol.asyncIterator = Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator");
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/observable.js
-  var require_observable = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/observable.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.Observable = exports.SubscriptionObserver = exports.Subscription = void 0;
-      require_symbols();
-      var _symbols_1 = require_symbols2();
-      var SymbolIterator = _symbols_1.getSymbol("iterator");
-      var SymbolObservable = _symbols_1.getSymbol("observable");
-      var SymbolSpecies = _symbols_1.getSymbol("species");
-      function getMethod(obj, key) {
-        const value = obj[key];
-        if (value == null) {
-          return void 0;
-        }
-        if (typeof value !== "function") {
-          throw new TypeError(value + " is not a function");
-        }
-        return value;
-      }
-      function getSpecies(obj) {
-        let ctor = obj.constructor;
-        if (ctor !== void 0) {
-          ctor = ctor[SymbolSpecies];
-          if (ctor === null) {
-            ctor = void 0;
-          }
-        }
-        return ctor !== void 0 ? ctor : Observable;
-      }
-      function isObservable(x) {
-        return x instanceof Observable;
-      }
-      function hostReportError(error) {
-        if (hostReportError.log) {
-          hostReportError.log(error);
-        } else {
-          setTimeout(() => {
-            throw error;
-          }, 0);
-        }
-      }
-      function enqueue(fn) {
-        Promise.resolve().then(() => {
-          try {
-            fn();
-          } catch (e) {
-            hostReportError(e);
-          }
-        });
-      }
-      function cleanupSubscription(subscription) {
-        const cleanup = subscription._cleanup;
-        if (cleanup === void 0) {
-          return;
-        }
-        subscription._cleanup = void 0;
-        if (!cleanup) {
-          return;
-        }
-        try {
-          if (typeof cleanup === "function") {
-            cleanup();
-          } else {
-            const unsubscribe = getMethod(cleanup, "unsubscribe");
-            if (unsubscribe) {
-              unsubscribe.call(cleanup);
-            }
-          }
-        } catch (e) {
-          hostReportError(e);
-        }
-      }
-      function closeSubscription(subscription) {
-        subscription._observer = void 0;
-        subscription._queue = void 0;
-        subscription._state = "closed";
-      }
-      function flushSubscription(subscription) {
-        const queue = subscription._queue;
-        if (!queue) {
-          return;
-        }
-        subscription._queue = void 0;
-        subscription._state = "ready";
-        for (const item of queue) {
-          notifySubscription(subscription, item.type, item.value);
-          if (subscription._state === "closed") {
-            break;
-          }
-        }
-      }
-      function notifySubscription(subscription, type, value) {
-        subscription._state = "running";
-        const observer = subscription._observer;
-        try {
-          const m = observer ? getMethod(observer, type) : void 0;
-          switch (type) {
-            case "next":
-              if (m)
-                m.call(observer, value);
-              break;
-            case "error":
-              closeSubscription(subscription);
-              if (m)
-                m.call(observer, value);
-              else
-                throw value;
-              break;
-            case "complete":
-              closeSubscription(subscription);
-              if (m)
-                m.call(observer);
-              break;
-          }
-        } catch (e) {
-          hostReportError(e);
-        }
-        if (subscription._state === "closed") {
-          cleanupSubscription(subscription);
-        } else if (subscription._state === "running") {
-          subscription._state = "ready";
-        }
-      }
-      function onNotify(subscription, type, value) {
-        if (subscription._state === "closed") {
-          return;
-        }
-        if (subscription._state === "buffering") {
-          subscription._queue = subscription._queue || [];
-          subscription._queue.push({ type, value });
-          return;
-        }
-        if (subscription._state !== "ready") {
-          subscription._state = "buffering";
-          subscription._queue = [{ type, value }];
-          enqueue(() => flushSubscription(subscription));
-          return;
-        }
-        notifySubscription(subscription, type, value);
-      }
-      var Subscription = class {
-        constructor(observer, subscriber) {
-          this._cleanup = void 0;
-          this._observer = observer;
-          this._queue = void 0;
-          this._state = "initializing";
-          const subscriptionObserver = new SubscriptionObserver(this);
-          try {
-            this._cleanup = subscriber.call(void 0, subscriptionObserver);
-          } catch (e) {
-            subscriptionObserver.error(e);
-          }
-          if (this._state === "initializing") {
-            this._state = "ready";
-          }
-        }
-        get closed() {
-          return this._state === "closed";
-        }
-        unsubscribe() {
-          if (this._state !== "closed") {
-            closeSubscription(this);
-            cleanupSubscription(this);
-          }
-        }
-      };
-      exports.Subscription = Subscription;
-      var SubscriptionObserver = class {
-        constructor(subscription) {
-          this._subscription = subscription;
-        }
-        get closed() {
-          return this._subscription._state === "closed";
-        }
-        next(value) {
-          onNotify(this._subscription, "next", value);
-        }
-        error(value) {
-          onNotify(this._subscription, "error", value);
-        }
-        complete() {
-          onNotify(this._subscription, "complete");
-        }
-      };
-      exports.SubscriptionObserver = SubscriptionObserver;
-      var Observable = class _Observable {
-        constructor(subscriber) {
-          if (!(this instanceof _Observable)) {
-            throw new TypeError("Observable cannot be called as a function");
-          }
-          if (typeof subscriber !== "function") {
-            throw new TypeError("Observable initializer must be a function");
-          }
-          this._subscriber = subscriber;
-        }
-        subscribe(nextOrObserver, onError, onComplete) {
-          if (typeof nextOrObserver !== "object" || nextOrObserver === null) {
-            nextOrObserver = {
-              next: nextOrObserver,
-              error: onError,
-              complete: onComplete
-            };
-          }
-          return new Subscription(nextOrObserver, this._subscriber);
-        }
-        pipe(first, ...mappers) {
-          let intermediate = this;
-          for (const mapper of [first, ...mappers]) {
-            intermediate = mapper(intermediate);
-          }
-          return intermediate;
-        }
-        tap(nextOrObserver, onError, onComplete) {
-          const tapObserver = typeof nextOrObserver !== "object" || nextOrObserver === null ? {
-            next: nextOrObserver,
-            error: onError,
-            complete: onComplete
-          } : nextOrObserver;
-          return new _Observable((observer) => {
-            return this.subscribe({
-              next(value) {
-                tapObserver.next && tapObserver.next(value);
-                observer.next(value);
-              },
-              error(error) {
-                tapObserver.error && tapObserver.error(error);
-                observer.error(error);
-              },
-              complete() {
-                tapObserver.complete && tapObserver.complete();
-                observer.complete();
-              },
-              start(subscription) {
-                tapObserver.start && tapObserver.start(subscription);
-              }
-            });
-          });
-        }
-        forEach(fn) {
-          return new Promise((resolve, reject) => {
-            if (typeof fn !== "function") {
-              reject(new TypeError(fn + " is not a function"));
-              return;
-            }
-            function done() {
-              subscription.unsubscribe();
-              resolve(void 0);
-            }
-            const subscription = this.subscribe({
-              next(value) {
-                try {
-                  fn(value, done);
-                } catch (e) {
-                  reject(e);
-                  subscription.unsubscribe();
-                }
-              },
-              error(error) {
-                reject(error);
-              },
-              complete() {
-                resolve(void 0);
-              }
-            });
-          });
-        }
-        map(fn) {
-          if (typeof fn !== "function") {
-            throw new TypeError(fn + " is not a function");
-          }
-          const C = getSpecies(this);
-          return new C((observer) => this.subscribe({
-            next(value) {
-              let propagatedValue = value;
-              try {
-                propagatedValue = fn(value);
-              } catch (e) {
-                return observer.error(e);
-              }
-              observer.next(propagatedValue);
-            },
-            error(e) {
-              observer.error(e);
-            },
-            complete() {
-              observer.complete();
-            }
-          }));
-        }
-        filter(fn) {
-          if (typeof fn !== "function") {
-            throw new TypeError(fn + " is not a function");
-          }
-          const C = getSpecies(this);
-          return new C((observer) => this.subscribe({
-            next(value) {
-              try {
-                if (!fn(value))
-                  return;
-              } catch (e) {
-                return observer.error(e);
-              }
-              observer.next(value);
-            },
-            error(e) {
-              observer.error(e);
-            },
-            complete() {
-              observer.complete();
-            }
-          }));
-        }
-        reduce(fn, seed) {
-          if (typeof fn !== "function") {
-            throw new TypeError(fn + " is not a function");
-          }
-          const C = getSpecies(this);
-          const hasSeed = arguments.length > 1;
-          let hasValue = false;
-          let acc = seed;
-          return new C((observer) => this.subscribe({
-            next(value) {
-              const first = !hasValue;
-              hasValue = true;
-              if (!first || hasSeed) {
-                try {
-                  acc = fn(acc, value);
-                } catch (e) {
-                  return observer.error(e);
-                }
-              } else {
-                acc = value;
-              }
-            },
-            error(e) {
-              observer.error(e);
-            },
-            complete() {
-              if (!hasValue && !hasSeed) {
-                return observer.error(new TypeError("Cannot reduce an empty sequence"));
-              }
-              observer.next(acc);
-              observer.complete();
-            }
-          }));
-        }
-        concat(...sources) {
-          const C = getSpecies(this);
-          return new C((observer) => {
-            let subscription;
-            let index = 0;
-            function startNext(next) {
-              subscription = next.subscribe({
-                next(v) {
-                  observer.next(v);
-                },
-                error(e) {
-                  observer.error(e);
-                },
-                complete() {
-                  if (index === sources.length) {
-                    subscription = void 0;
-                    observer.complete();
-                  } else {
-                    startNext(C.from(sources[index++]));
-                  }
-                }
-              });
-            }
-            startNext(this);
-            return () => {
-              if (subscription) {
-                subscription.unsubscribe();
-                subscription = void 0;
-              }
-            };
-          });
-        }
-        flatMap(fn) {
-          if (typeof fn !== "function") {
-            throw new TypeError(fn + " is not a function");
-          }
-          const C = getSpecies(this);
-          return new C((observer) => {
-            const subscriptions = [];
-            const outer = this.subscribe({
-              next(value) {
-                let normalizedValue;
-                if (fn) {
-                  try {
-                    normalizedValue = fn(value);
-                  } catch (e) {
-                    return observer.error(e);
-                  }
-                } else {
-                  normalizedValue = value;
-                }
-                const inner = C.from(normalizedValue).subscribe({
-                  next(innerValue) {
-                    observer.next(innerValue);
-                  },
-                  error(e) {
-                    observer.error(e);
-                  },
-                  complete() {
-                    const i = subscriptions.indexOf(inner);
-                    if (i >= 0)
-                      subscriptions.splice(i, 1);
-                    completeIfDone();
-                  }
-                });
-                subscriptions.push(inner);
-              },
-              error(e) {
-                observer.error(e);
-              },
-              complete() {
-                completeIfDone();
-              }
-            });
-            function completeIfDone() {
-              if (outer.closed && subscriptions.length === 0) {
-                observer.complete();
-              }
-            }
-            return () => {
-              subscriptions.forEach((s) => s.unsubscribe());
-              outer.unsubscribe();
-            };
-          });
-        }
-        [(Symbol.observable, SymbolObservable)]() {
-          return this;
-        }
-        static from(x) {
-          const C = typeof this === "function" ? this : _Observable;
-          if (x == null) {
-            throw new TypeError(x + " is not an object");
-          }
-          const observableMethod = getMethod(x, SymbolObservable);
-          if (observableMethod) {
-            const observable = observableMethod.call(x);
-            if (Object(observable) !== observable) {
-              throw new TypeError(observable + " is not an object");
-            }
-            if (isObservable(observable) && observable.constructor === C) {
-              return observable;
-            }
-            return new C((observer) => observable.subscribe(observer));
-          }
-          if (_symbols_1.hasSymbol("iterator")) {
-            const iteratorMethod = getMethod(x, SymbolIterator);
-            if (iteratorMethod) {
-              return new C((observer) => {
-                enqueue(() => {
-                  if (observer.closed)
-                    return;
-                  for (const item of iteratorMethod.call(x)) {
-                    observer.next(item);
-                    if (observer.closed)
-                      return;
-                  }
-                  observer.complete();
-                });
-              });
-            }
-          }
-          if (Array.isArray(x)) {
-            return new C((observer) => {
-              enqueue(() => {
-                if (observer.closed)
-                  return;
-                for (const item of x) {
-                  observer.next(item);
-                  if (observer.closed)
-                    return;
-                }
-                observer.complete();
-              });
-            });
-          }
-          throw new TypeError(x + " is not observable");
-        }
-        static of(...items) {
-          const C = typeof this === "function" ? this : _Observable;
-          return new C((observer) => {
-            enqueue(() => {
-              if (observer.closed)
-                return;
-              for (const item of items) {
-                observer.next(item);
-                if (observer.closed)
-                  return;
-              }
-              observer.complete();
-            });
-          });
-        }
-        static get [SymbolSpecies]() {
-          return this;
-        }
-      };
-      exports.Observable = Observable;
-      if (_symbols_1.hasSymbols()) {
-        Object.defineProperty(Observable, Symbol("extensions"), {
-          value: {
-            symbol: SymbolObservable,
-            hostReportError
-          },
-          configurable: true
-        });
-      }
-      exports.default = Observable;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/unsubscribe.js
-  var require_unsubscribe = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/unsubscribe.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      function unsubscribe(subscription) {
-        if (typeof subscription === "function") {
-          subscription();
-        } else if (subscription && typeof subscription.unsubscribe === "function") {
-          subscription.unsubscribe();
-        }
-      }
-      exports.default = unsubscribe;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/filter.js
-  var require_filter = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/filter.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());
-        });
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var _scheduler_1 = require_scheduler();
-      var observable_1 = require_observable();
-      var unsubscribe_1 = require_unsubscribe();
-      function filter(test) {
-        return (observable) => {
-          return new observable_1.default((observer) => {
-            const scheduler = new _scheduler_1.AsyncSerialScheduler(observer);
-            const subscription = observable.subscribe({
-              complete() {
-                scheduler.complete();
-              },
-              error(error) {
-                scheduler.error(error);
-              },
-              next(input) {
-                scheduler.schedule((next) => __awaiter2(this, void 0, void 0, function* () {
-                  if (yield test(input)) {
-                    next(input);
-                  }
-                }));
-              }
-            });
-            return () => unsubscribe_1.default(subscription);
-          });
-        };
-      }
-      exports.default = filter;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_util.js
-  var require_util = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/_util.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.isIterator = exports.isAsyncIterator = void 0;
-      var _symbols_1 = require_symbols2();
-      function isAsyncIterator(thing) {
-        return thing && _symbols_1.hasSymbol("asyncIterator") && thing[Symbol.asyncIterator];
-      }
-      exports.isAsyncIterator = isAsyncIterator;
-      function isIterator(thing) {
-        return thing && _symbols_1.hasSymbol("iterator") && thing[Symbol.iterator];
-      }
-      exports.isIterator = isIterator;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/flatMap.js
-  var require_flatMap = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/flatMap.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 __asyncValues = exports && exports.__asyncValues || function(o) {
-        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-        var m = o[Symbol.asyncIterator], i;
-        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-          return this;
-        }, i);
-        function verb(n) {
-          i[n] = o[n] && function(v) {
-            return new Promise(function(resolve, reject) {
-              v = o[n](v), settle(resolve, reject, v.done, v.value);
-            });
-          };
-        }
-        function settle(resolve, reject, d, v) {
-          Promise.resolve(v).then(function(v2) {
-            resolve({ value: v2, done: d });
-          }, reject);
-        }
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var _scheduler_1 = require_scheduler();
-      var _util_1 = require_util();
-      var observable_1 = require_observable();
-      var unsubscribe_1 = require_unsubscribe();
-      function flatMap(mapper) {
-        return (observable) => {
-          return new observable_1.default((observer) => {
-            const scheduler = new _scheduler_1.AsyncSerialScheduler(observer);
-            const subscription = observable.subscribe({
-              complete() {
-                scheduler.complete();
-              },
-              error(error) {
-                scheduler.error(error);
-              },
-              next(input) {
-                scheduler.schedule((next) => __awaiter2(this, void 0, void 0, function* () {
-                  var e_1, _a2;
-                  const mapped = yield mapper(input);
-                  if (_util_1.isIterator(mapped) || _util_1.isAsyncIterator(mapped)) {
-                    try {
-                      for (var mapped_1 = __asyncValues(mapped), mapped_1_1; mapped_1_1 = yield mapped_1.next(), !mapped_1_1.done; ) {
-                        const element = mapped_1_1.value;
-                        next(element);
-                      }
-                    } catch (e_1_1) {
-                      e_1 = { error: e_1_1 };
-                    } finally {
-                      try {
-                        if (mapped_1_1 && !mapped_1_1.done && (_a2 = mapped_1.return)) yield _a2.call(mapped_1);
-                      } finally {
-                        if (e_1) throw e_1.error;
-                      }
-                    }
-                  } else {
-                    mapped.map((output) => next(output));
-                  }
-                }));
-              }
-            });
-            return () => unsubscribe_1.default(subscription);
-          });
-        };
-      }
-      exports.default = flatMap;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/interval.js
-  var require_interval = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/interval.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var observable_1 = require_observable();
-      function interval(period) {
-        return new observable_1.Observable((observer) => {
-          let counter = 0;
-          const handle = setInterval(() => {
-            observer.next(counter++);
-          }, period);
-          return () => clearInterval(handle);
-        });
-      }
-      exports.default = interval;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/map.js
-  var require_map = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/map.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());
-        });
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var _scheduler_1 = require_scheduler();
-      var observable_1 = require_observable();
-      var unsubscribe_1 = require_unsubscribe();
-      function map(mapper) {
-        return (observable) => {
-          return new observable_1.default((observer) => {
-            const scheduler = new _scheduler_1.AsyncSerialScheduler(observer);
-            const subscription = observable.subscribe({
-              complete() {
-                scheduler.complete();
-              },
-              error(error) {
-                scheduler.error(error);
-              },
-              next(input) {
-                scheduler.schedule((next) => __awaiter2(this, void 0, void 0, function* () {
-                  const mapped = yield mapper(input);
-                  next(mapped);
-                }));
-              }
-            });
-            return () => unsubscribe_1.default(subscription);
-          });
-        };
-      }
-      exports.default = map;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/merge.js
-  var require_merge = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/merge.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var observable_1 = require_observable();
-      var unsubscribe_1 = require_unsubscribe();
-      function merge(...observables) {
-        if (observables.length === 0) {
-          return observable_1.Observable.from([]);
-        }
-        return new observable_1.Observable((observer) => {
-          let completed = 0;
-          const subscriptions = observables.map((input) => {
-            return input.subscribe({
-              error(error) {
-                observer.error(error);
-                unsubscribeAll();
-              },
-              next(value) {
-                observer.next(value);
-              },
-              complete() {
-                if (++completed === observables.length) {
-                  observer.complete();
-                  unsubscribeAll();
-                }
-              }
-            });
-          });
-          const unsubscribeAll = () => {
-            subscriptions.forEach((subscription) => unsubscribe_1.default(subscription));
-          };
-          return unsubscribeAll;
-        });
-      }
-      exports.default = merge;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/subject.js
-  var require_subject = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/subject.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var observable_1 = require_observable();
-      var MulticastSubject = class extends observable_1.default {
-        constructor() {
-          super((observer) => {
-            this._observers.add(observer);
-            return () => this._observers.delete(observer);
-          });
-          this._observers = /* @__PURE__ */ new Set();
-        }
-        next(value) {
-          for (const observer of this._observers) {
-            observer.next(value);
-          }
-        }
-        error(error) {
-          for (const observer of this._observers) {
-            observer.error(error);
-          }
-        }
-        complete() {
-          for (const observer of this._observers) {
-            observer.complete();
-          }
-        }
-      };
-      exports.default = MulticastSubject;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/multicast.js
-  var require_multicast = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/multicast.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var observable_1 = require_observable();
-      var subject_1 = require_subject();
-      var unsubscribe_1 = require_unsubscribe();
-      function multicast(coldObservable) {
-        const subject = new subject_1.default();
-        let sourceSubscription;
-        let subscriberCount = 0;
-        return new observable_1.default((observer) => {
-          if (!sourceSubscription) {
-            sourceSubscription = coldObservable.subscribe(subject);
-          }
-          const subscription = subject.subscribe(observer);
-          subscriberCount++;
-          return () => {
-            subscriberCount--;
-            subscription.unsubscribe();
-            if (subscriberCount === 0) {
-              unsubscribe_1.default(sourceSubscription);
-              sourceSubscription = void 0;
-            }
-          };
-        });
-      }
-      exports.default = multicast;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/scan.js
-  var require_scan = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/scan.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());
-        });
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var _scheduler_1 = require_scheduler();
-      var observable_1 = require_observable();
-      var unsubscribe_1 = require_unsubscribe();
-      function scan(accumulator, seed) {
-        return (observable) => {
-          return new observable_1.default((observer) => {
-            let accumulated;
-            let index = 0;
-            const scheduler = new _scheduler_1.AsyncSerialScheduler(observer);
-            const subscription = observable.subscribe({
-              complete() {
-                scheduler.complete();
-              },
-              error(error) {
-                scheduler.error(error);
-              },
-              next(value) {
-                scheduler.schedule((next) => __awaiter2(this, void 0, void 0, function* () {
-                  const prevAcc = index === 0 ? typeof seed === "undefined" ? value : seed : accumulated;
-                  accumulated = yield accumulator(prevAcc, value, index++);
-                  next(accumulated);
-                }));
-              }
-            });
-            return () => unsubscribe_1.default(subscription);
-          });
-        };
-      }
-      exports.default = scan;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/index.js
-  var require_dist = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/dist/index.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.unsubscribe = exports.Subject = exports.scan = exports.Observable = exports.multicast = exports.merge = exports.map = exports.interval = exports.flatMap = exports.filter = void 0;
-      var filter_1 = require_filter();
-      Object.defineProperty(exports, "filter", { enumerable: true, get: function() {
-        return filter_1.default;
-      } });
-      var flatMap_1 = require_flatMap();
-      Object.defineProperty(exports, "flatMap", { enumerable: true, get: function() {
-        return flatMap_1.default;
-      } });
-      var interval_1 = require_interval();
-      Object.defineProperty(exports, "interval", { enumerable: true, get: function() {
-        return interval_1.default;
-      } });
-      var map_1 = require_map();
-      Object.defineProperty(exports, "map", { enumerable: true, get: function() {
-        return map_1.default;
-      } });
-      var merge_1 = require_merge();
-      Object.defineProperty(exports, "merge", { enumerable: true, get: function() {
-        return merge_1.default;
-      } });
-      var multicast_1 = require_multicast();
-      Object.defineProperty(exports, "multicast", { enumerable: true, get: function() {
-        return multicast_1.default;
-      } });
-      var observable_1 = require_observable();
-      Object.defineProperty(exports, "Observable", { enumerable: true, get: function() {
-        return observable_1.default;
-      } });
-      var scan_1 = require_scan();
-      Object.defineProperty(exports, "scan", { enumerable: true, get: function() {
-        return scan_1.default;
-      } });
-      var subject_1 = require_subject();
-      Object.defineProperty(exports, "Subject", { enumerable: true, get: function() {
-        return subject_1.default;
-      } });
-      var unsubscribe_1 = require_unsubscribe();
-      Object.defineProperty(exports, "unsubscribe", { enumerable: true, get: function() {
-        return unsubscribe_1.default;
-      } });
-    }
-  });
-
-  // ../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/index.js
-  var require_package2 = __commonJS({
-    "../../../../../../node_modules/.store/observable-fns-npm-0.6.1-305598d6d4/package/index.js"(exports, module) {
-      module.exports = require_dist();
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/ponyfills.js
-  var require_ponyfills = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/ponyfills.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.allSettled = allSettled;
-      function allSettled(values) {
-        return Promise.all(values.map((item) => {
-          const onFulfill = (value) => {
-            return { status: "fulfilled", value };
-          };
-          const onReject = (reason) => {
-            return { reason, status: "rejected" };
-          };
-          const itemPromise = Promise.resolve(item);
-          try {
-            return itemPromise.then(onFulfill, onReject);
-          } catch (error) {
-            return Promise.reject(error);
-          }
-        }));
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/pool-types.js
-  var require_pool_types = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/pool-types.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.PoolEventType = void 0;
-      var PoolEventType;
-      (function(PoolEventType2) {
-        PoolEventType2["initialized"] = "initialized";
-        PoolEventType2["taskCanceled"] = "taskCanceled";
-        PoolEventType2["taskCompleted"] = "taskCompleted";
-        PoolEventType2["taskFailed"] = "taskFailed";
-        PoolEventType2["taskQueued"] = "taskQueued";
-        PoolEventType2["taskQueueDrained"] = "taskQueueDrained";
-        PoolEventType2["taskStart"] = "taskStart";
-        PoolEventType2["terminated"] = "terminated";
-      })(PoolEventType || (exports.PoolEventType = PoolEventType = {}));
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/symbols.js
-  var require_symbols3 = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/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/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/thread.js
-  var require_thread = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/thread.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.Thread = void 0;
-      var symbols_1 = require_symbols3();
-      function fail(message) {
-        throw new Error(message);
-      }
-      exports.Thread = {
-        errors(thread) {
-          return thread[symbols_1.$errors] || fail("Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
-        },
-        events(thread) {
-          return thread[symbols_1.$events] || fail("Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
-        },
-        terminate(thread) {
-          return thread[symbols_1.$terminate]();
-        }
-      };
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/pool.js
-  var require_pool = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/pool.js"(exports) {
-      "use strict";
-      var __importDefault = exports && exports.__importDefault || function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.Thread = exports.PoolEventType = exports.Pool = void 0;
-      var debug_1 = __importDefault(require_browser());
-      var observable_fns_1 = require_package2();
-      var ponyfills_1 = require_ponyfills();
-      var implementation_1 = require_implementation_browser();
-      var pool_types_1 = require_pool_types();
-      var thread_1 = require_thread();
-      var nextPoolID = 1;
-      function createArray(size) {
-        const array = [];
-        for (let index = 0; index < size; index++) {
-          array.push(index);
-        }
-        return array;
-      }
-      function delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-      }
-      function flatMap(array, mapper) {
-        return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
-      }
-      function slugify(text) {
-        return text.replaceAll(/\W/g, " ").trim().replaceAll(/\s+/g, "-");
-      }
-      function spawnWorkers(spawnWorker, count) {
-        return createArray(count).map(() => ({
-          init: spawnWorker(),
-          runningTasks: []
-        }));
-      }
-      var WorkerPool = class {
-        debug;
-        eventObservable;
-        options;
-        workers;
-        eventSubject = new observable_fns_1.Subject();
-        initErrors = [];
-        isClosing = false;
-        nextTaskID = 1;
-        taskQueue = [];
-        constructor(spawnWorker, optionsOrSize) {
-          const options = typeof optionsOrSize === "number" ? { size: optionsOrSize } : optionsOrSize || {};
-          const { size = implementation_1.defaultPoolSize } = options;
-          this.debug = (0, debug_1.default)(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
-          this.options = options;
-          this.workers = spawnWorkers(spawnWorker, size);
-          this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
-          Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
-            size: this.workers.length,
-            type: pool_types_1.PoolEventType.initialized
-          }), (error) => {
-            this.debug("Error while initializing pool worker:", error);
-            this.eventSubject.error(error);
-            this.initErrors.push(error);
-          });
-        }
-        findIdlingWorker() {
-          const { concurrency = 1 } = this.options;
-          return this.workers.find((worker) => worker.runningTasks.length < concurrency);
-        }
-        async runPoolTask(worker, task) {
-          const workerID = this.workers.indexOf(worker) + 1;
-          this.debug(`Running task #${task.id} on worker #${workerID}...`);
-          this.eventSubject.next({
-            taskID: task.id,
-            type: pool_types_1.PoolEventType.taskStart,
-            workerID
-          });
-          try {
-            const returnValue = await task.run(await worker.init);
-            this.debug(`Task #${task.id} completed successfully`);
-            this.eventSubject.next({
-              returnValue,
-              taskID: task.id,
-              type: pool_types_1.PoolEventType.taskCompleted,
-              workerID
-            });
-          } catch (error) {
-            this.debug(`Task #${task.id} failed`);
-            this.eventSubject.next({
-              error,
-              taskID: task.id,
-              type: pool_types_1.PoolEventType.taskFailed,
-              workerID
-            });
-          }
-        }
-        async run(worker, task) {
-          const runPromise = (async () => {
-            const removeTaskFromWorkersRunningTasks = () => {
-              worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
-            };
-            await delay(0);
-            try {
-              await this.runPoolTask(worker, task);
-            } finally {
-              removeTaskFromWorkersRunningTasks();
-              if (!this.isClosing) {
-                this.scheduleWork();
-              }
-            }
-          })();
-          worker.runningTasks.push(runPromise);
-        }
-        scheduleWork() {
-          this.debug("Attempt de-queueing a task in order to run it...");
-          const availableWorker = this.findIdlingWorker();
-          if (!availableWorker)
-            return;
-          const nextTask = this.taskQueue.shift();
-          if (!nextTask) {
-            this.debug("Task queue is empty");
-            this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
-            return;
-          }
-          this.run(availableWorker, nextTask);
-        }
-        taskCompletion(taskID) {
-          return new Promise((resolve, reject) => {
-            const eventSubscription = this.events().subscribe((event) => {
-              if (event.type === pool_types_1.PoolEventType.taskCompleted && event.taskID === taskID) {
-                eventSubscription.unsubscribe();
-                resolve(event.returnValue);
-              } else if (event.type === pool_types_1.PoolEventType.taskFailed && event.taskID === taskID) {
-                eventSubscription.unsubscribe();
-                reject(event.error);
-              } else if (event.type === pool_types_1.PoolEventType.terminated) {
-                eventSubscription.unsubscribe();
-                reject(new Error("Pool has been terminated before task was run."));
-              }
-            });
-          });
-        }
-        async settled(allowResolvingImmediately = false) {
-          const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
-          const taskFailures = [];
-          const failureSubscription = this.eventObservable.subscribe((event) => {
-            if (event.type === pool_types_1.PoolEventType.taskFailed) {
-              taskFailures.push(event.error);
-            }
-          });
-          if (this.initErrors.length > 0) {
-            throw this.initErrors[0];
-          }
-          if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
-            return taskFailures;
-          }
-          await new Promise((resolve, reject) => {
-            const subscription = this.eventObservable.subscribe({
-              error: reject,
-              next(event) {
-                if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
-                  subscription.unsubscribe();
-                  resolve(void 0);
-                }
-              }
-            });
-          });
-          await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
-          failureSubscription.unsubscribe();
-          return taskFailures;
-        }
-        async completed(allowResolvingImmediately = false) {
-          const settlementPromise = this.settled(allowResolvingImmediately);
-          const earlyExitPromise = new Promise((resolve, reject) => {
-            const subscription = this.eventObservable.subscribe({
-              error: reject,
-              next(event) {
-                if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
-                  subscription.unsubscribe();
-                  resolve(settlementPromise);
-                } else if (event.type === pool_types_1.PoolEventType.taskFailed) {
-                  subscription.unsubscribe();
-                  reject(event.error);
-                }
-              }
-            });
-          });
-          const errors = await Promise.race([settlementPromise, earlyExitPromise]);
-          if (errors.length > 0) {
-            throw errors[0];
-          }
-        }
-        events() {
-          return this.eventObservable;
-        }
-        queue(taskFunction) {
-          const { maxQueuedJobs = Number.POSITIVE_INFINITY } = this.options;
-          if (this.isClosing) {
-            throw new Error("Cannot schedule pool tasks after terminate() has been called.");
-          }
-          if (this.initErrors.length > 0) {
-            throw this.initErrors[0];
-          }
-          const taskID = this.nextTaskID++;
-          const taskCompletion = this.taskCompletion(taskID);
-          taskCompletion.catch((error) => {
-            this.debug(`Task #${taskID} errored:`, error);
-          });
-          const task = {
-            cancel: () => {
-              if (!this.taskQueue.includes(task))
-                return;
-              this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
-              this.eventSubject.next({
-                taskID: task.id,
-                type: pool_types_1.PoolEventType.taskCanceled
-              });
-            },
-            id: taskID,
-            run: taskFunction,
-            then: taskCompletion.then.bind(taskCompletion)
-          };
-          if (this.taskQueue.length >= maxQueuedJobs) {
-            throw new Error("Maximum number of pool tasks queued. Refusing to queue another one.\nThis usually happens for one of two reasons: We are either at peak workload right now or some tasks just won't finish, thus blocking the pool.");
-          }
-          this.debug(`Queueing task #${task.id}...`);
-          this.taskQueue.push(task);
-          this.eventSubject.next({
-            taskID: task.id,
-            type: pool_types_1.PoolEventType.taskQueued
-          });
-          this.scheduleWork();
-          return task;
-        }
-        async terminate(force) {
-          this.isClosing = true;
-          if (!force) {
-            await this.completed(true);
-          }
-          this.eventSubject.next({
-            remainingQueue: [...this.taskQueue],
-            type: pool_types_1.PoolEventType.terminated
-          });
-          this.eventSubject.complete();
-          await Promise.all(this.workers.map(async (worker) => thread_1.Thread.terminate(await worker.init)));
-        }
-      };
-      __publicField(WorkerPool, "EventType", pool_types_1.PoolEventType);
-      function PoolConstructor(spawnWorker, optionsOrSize) {
-        return new WorkerPool(spawnWorker, optionsOrSize);
-      }
-      PoolConstructor.EventType = pool_types_1.PoolEventType;
-      exports.Pool = PoolConstructor;
-      var pool_types_2 = require_pool_types();
-      Object.defineProperty(exports, "PoolEventType", { enumerable: true, get: function() {
-        return pool_types_2.PoolEventType;
-      } });
-      var thread_2 = require_thread();
-      Object.defineProperty(exports, "Thread", { enumerable: true, get: function() {
-        return thread_2.Thread;
-      } });
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/promise.js
-  var require_promise = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/promise.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createPromiseWithResolver = createPromiseWithResolver;
-      var doNothing = () => void 0;
-      function createPromiseWithResolver() {
-        let alreadyResolved = false;
-        let resolvedTo;
-        let resolver = doNothing;
-        const promise = new Promise((resolve) => {
-          if (alreadyResolved) {
-            resolve(resolvedTo);
-          } else {
-            resolver = resolve;
-          }
-        });
-        const exposedResolver = (value) => {
-          alreadyResolved = true;
-          resolvedTo = value;
-          resolver(resolvedTo);
-        };
-        return [promise, exposedResolver];
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/types/master.js
-  var require_master = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/types/master.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.WorkerEventType = void 0;
-      var WorkerEventType;
-      (function(WorkerEventType2) {
-        WorkerEventType2["internalError"] = "internalError";
-        WorkerEventType2["message"] = "message";
-        WorkerEventType2["termination"] = "termination";
-      })(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/observable-promise.js
-  var require_observable_promise = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/observable-promise.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.ObservablePromise = void 0;
-      var observable_fns_1 = require_package2();
-      var doNothing = () => {
-      };
-      var returnInput = (input) => input;
-      var runDeferred = (fn) => Promise.resolve().then(fn);
-      function fail(error) {
-        throw error;
-      }
-      function isThenable(thing) {
-        return thing && typeof thing.then === "function";
-      }
-      var ObservablePromise = class _ObservablePromise extends observable_fns_1.Observable {
-        [Symbol.toStringTag] = "[object ObservablePromise]";
-        initHasRun = false;
-        fulfillmentCallbacks = [];
-        rejectionCallbacks = [];
-        firstValue;
-        firstValueSet = false;
-        rejection;
-        state = "pending";
-        constructor(init) {
-          super((originalObserver) => {
-            const self2 = this;
-            const observer = {
-              ...originalObserver,
-              complete() {
-                originalObserver.complete();
-                self2.onCompletion();
-              },
-              error(error) {
-                originalObserver.error(error);
-                self2.onError(error);
-              },
-              next(value) {
-                originalObserver.next(value);
-                self2.onNext(value);
-              }
-            };
-            try {
-              this.initHasRun = true;
-              return init(observer);
-            } catch (error) {
-              observer.error(error);
-            }
-          });
-        }
-        onNext(value) {
-          if (!this.firstValueSet) {
-            this.firstValue = value;
-            this.firstValueSet = true;
-          }
-        }
-        onError(error) {
-          this.state = "rejected";
-          this.rejection = error;
-          for (const onRejected of this.rejectionCallbacks) {
-            runDeferred(() => onRejected(error));
-          }
-        }
-        onCompletion() {
-          this.state = "fulfilled";
-          for (const onFulfilled of this.fulfillmentCallbacks) {
-            runDeferred(() => onFulfilled(this.firstValue));
-          }
-        }
-        then(onFulfilledRaw, onRejectedRaw) {
-          const onFulfilled = onFulfilledRaw || returnInput;
-          const onRejected = onRejectedRaw || fail;
-          let onRejectedCalled = false;
-          return new Promise((resolve, reject) => {
-            const rejectionCallback = (error) => {
-              if (onRejectedCalled)
-                return;
-              onRejectedCalled = true;
-              try {
-                resolve(onRejected(error));
-              } catch (anotherError) {
-                reject(anotherError);
-              }
-            };
-            const fulfillmentCallback = (value) => {
-              try {
-                resolve(onFulfilled(value));
-              } catch (error) {
-                rejectionCallback(error);
-              }
-            };
-            if (!this.initHasRun) {
-              this.subscribe({ error: rejectionCallback });
-            }
-            if (this.state === "fulfilled") {
-              return resolve(onFulfilled(this.firstValue));
-            }
-            if (this.state === "rejected") {
-              onRejectedCalled = true;
-              return resolve(onRejected(this.rejection));
-            }
-            this.fulfillmentCallbacks.push(fulfillmentCallback);
-            this.rejectionCallbacks.push(rejectionCallback);
-          });
-        }
-        catch(onRejected) {
-          return this.then(void 0, onRejected);
-        }
-        finally(onCompleted) {
-          const handler = onCompleted || doNothing;
-          return this.then((value) => {
-            handler();
-            return value;
-          }, () => handler());
-        }
-        static from(thing) {
-          return isThenable(thing) ? new _ObservablePromise((observer) => {
-            const onFulfilled = (value) => {
-              observer.next(value);
-              observer.complete();
-            };
-            const onRejected = (error) => {
-              observer.error(error);
-            };
-            thing.then(onFulfilled, onRejected);
-          }) : super.from(thing);
-        }
-      };
-      exports.ObservablePromise = ObservablePromise;
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/transferable.js
-  var require_transferable = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/transferable.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.isTransferDescriptor = isTransferDescriptor;
-      exports.Transfer = Transfer;
-      var symbols_1 = require_symbols3();
-      function isTransferable(thing) {
-        if (!thing || typeof thing !== "object")
-          return false;
-        return true;
-      }
-      function isTransferDescriptor(thing) {
-        return thing && typeof thing === "object" && thing[symbols_1.$transferable];
-      }
-      function Transfer(payload, transferables) {
-        if (!transferables) {
-          if (!isTransferable(payload))
-            throw new Error("Not transferable");
-          transferables = [payload];
-        }
-        return {
-          [symbols_1.$transferable]: true,
-          send: payload,
-          transferables
-        };
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/types/messages.js
-  var require_messages = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/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 = MasterMessageType = {}));
-      var WorkerMessageType;
-      (function(WorkerMessageType2) {
-        WorkerMessageType2["error"] = "error";
-        WorkerMessageType2["init"] = "init";
-        WorkerMessageType2["result"] = "result";
-        WorkerMessageType2["running"] = "running";
-        WorkerMessageType2["uncaughtError"] = "uncaughtError";
-      })(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/invocation-proxy.js
-  var require_invocation_proxy = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/invocation-proxy.js"(exports) {
-      "use strict";
-      var __importDefault = exports && exports.__importDefault || function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createProxyFunction = createProxyFunction;
-      exports.createProxyModule = createProxyModule;
-      var debug_1 = __importDefault(require_browser());
-      var observable_fns_1 = require_package2();
-      var common_1 = require_common();
-      var observable_promise_1 = require_observable_promise();
-      var transferable_1 = require_transferable();
-      var messages_1 = require_messages();
-      var debugMessages = (0, debug_1.default)("threads:master:messages");
-      var nextJobUID = 1;
-      var dedupe = (array) => [...new Set(array)];
-      var isJobErrorMessage = (data) => data && data.type === messages_1.WorkerMessageType.error;
-      var isJobResultMessage = (data) => data && data.type === messages_1.WorkerMessageType.result;
-      var isJobStartMessage = (data) => data && data.type === messages_1.WorkerMessageType.running;
-      function createObservableForJob(worker, jobUID) {
-        return new observable_fns_1.Observable((observer) => {
-          let asyncType;
-          const messageHandler = (event) => {
-            debugMessages("Message from worker:", event.data);
-            if (!event.data || event.data.uid !== jobUID)
-              return;
-            if (isJobStartMessage(event.data)) {
-              asyncType = event.data.resultType;
-            } else if (isJobResultMessage(event.data)) {
-              if (asyncType === "promise") {
-                if (event.data.payload !== void 0) {
-                  observer.next((0, common_1.deserialize)(event.data.payload));
-                }
-                observer.complete();
-                worker.removeEventListener("message", messageHandler);
-              } else {
-                if (event.data.payload) {
-                  observer.next((0, common_1.deserialize)(event.data.payload));
-                }
-                if (event.data.complete) {
-                  observer.complete();
-                  worker.removeEventListener("message", messageHandler);
-                }
-              }
-            } else if (isJobErrorMessage(event.data)) {
-              const error = (0, common_1.deserialize)(event.data.error);
-              if (asyncType === "promise" || !asyncType) {
-                observer.error(error);
-              } else {
-                observer.error(error);
-              }
-              worker.removeEventListener("message", messageHandler);
-            }
-          };
-          worker.addEventListener("message", messageHandler);
-          return () => {
-            if (asyncType === "observable" || !asyncType) {
-              const cancelMessage = {
-                type: messages_1.MasterMessageType.cancel,
-                uid: jobUID
-              };
-              worker.postMessage(cancelMessage);
-            }
-            worker.removeEventListener("message", messageHandler);
-          };
-        });
-      }
-      function prepareArguments(rawArgs) {
-        if (rawArgs.length === 0) {
-          return {
-            args: [],
-            transferables: []
-          };
-        }
-        const args = [];
-        const transferables = [];
-        for (const arg of rawArgs) {
-          if ((0, transferable_1.isTransferDescriptor)(arg)) {
-            args.push((0, common_1.serialize)(arg.send));
-            transferables.push(...arg.transferables);
-          } else {
-            args.push((0, common_1.serialize)(arg));
-          }
-        }
-        return {
-          args,
-          transferables: transferables.length === 0 ? transferables : dedupe(transferables)
-        };
-      }
-      function createProxyFunction(worker, method) {
-        return (...rawArgs) => {
-          const uid = nextJobUID++;
-          const { args, transferables } = prepareArguments(rawArgs);
-          const runMessage = {
-            args,
-            method,
-            type: messages_1.MasterMessageType.run,
-            uid
-          };
-          debugMessages("Sending command to run function to worker:", runMessage);
-          try {
-            worker.postMessage(runMessage, transferables);
-          } catch (error) {
-            return observable_promise_1.ObservablePromise.from(Promise.reject(error));
-          }
-          return observable_promise_1.ObservablePromise.from((0, observable_fns_1.multicast)(createObservableForJob(worker, uid)));
-        };
-      }
-      function createProxyModule(worker, methodNames) {
-        const proxy = {};
-        for (const methodName of methodNames) {
-          proxy[methodName] = createProxyFunction(worker, methodName);
-        }
-        return proxy;
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/spawn.js
-  var require_spawn = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/spawn.js"(exports) {
-      "use strict";
-      var __importDefault = exports && exports.__importDefault || function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.spawn = spawn;
-      var debug_1 = __importDefault(require_browser());
-      var observable_fns_1 = require_package2();
-      var common_1 = require_common();
-      var promise_1 = require_promise();
-      var symbols_1 = require_symbols3();
-      var master_1 = require_master();
-      var invocation_proxy_1 = require_invocation_proxy();
-      var debugMessages = (0, debug_1.default)("threads:master:messages");
-      var debugSpawn = (0, debug_1.default)("threads:master:spawn");
-      var debugThreadUtils = (0, debug_1.default)("threads:master:thread-utils");
-      var isInitMessage = (data) => data && data.type === "init";
-      var isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
-      var initMessageTimeout = typeof process !== "undefined" && process.env !== void 0 && process.env.THREADS_WORKER_INIT_TIMEOUT ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10) : 1e4;
-      async function withTimeout(promise, timeoutInMs, errorMessage) {
-        let timeoutHandle;
-        const timeout = new Promise((resolve, reject) => {
-          timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs);
-        });
-        const result = await Promise.race([promise, timeout]);
-        clearTimeout(timeoutHandle);
-        return result;
-      }
-      function receiveInitMessage(worker) {
-        return new Promise((resolve, reject) => {
-          const messageHandler = (event) => {
-            debugMessages("Message from worker before finishing initialization:", event.data);
-            if (isInitMessage(event.data)) {
-              worker.removeEventListener("message", messageHandler);
-              resolve(event.data);
-            } else if (isUncaughtErrorMessage(event.data)) {
-              worker.removeEventListener("message", messageHandler);
-              reject((0, common_1.deserialize)(event.data.error));
-            }
-          };
-          worker.addEventListener("message", messageHandler);
-        });
-      }
-      function createEventObservable(worker, workerTermination) {
-        return new observable_fns_1.Observable((observer) => {
-          const messageHandler = (messageEvent) => {
-            const workerEvent = {
-              data: messageEvent.data,
-              type: master_1.WorkerEventType.message
-            };
-            observer.next(workerEvent);
-          };
-          const rejectionHandler = (errorEvent) => {
-            debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
-            const workerEvent = {
-              error: new Error(errorEvent.reason),
-              type: master_1.WorkerEventType.internalError
-            };
-            observer.next(workerEvent);
-          };
-          worker.addEventListener("message", messageHandler);
-          worker.addEventListener("unhandledrejection", rejectionHandler);
-          workerTermination.then(() => {
-            const terminationEvent = { type: master_1.WorkerEventType.termination };
-            worker.removeEventListener("message", messageHandler);
-            worker.removeEventListener("unhandledrejection", rejectionHandler);
-            observer.next(terminationEvent);
-            observer.complete();
-          });
-        });
-      }
-      function createTerminator(worker) {
-        const [termination, resolver] = (0, promise_1.createPromiseWithResolver)();
-        const terminate = async () => {
-          debugThreadUtils("Terminating worker");
-          await worker.terminate();
-          resolver();
-        };
-        return { terminate, termination };
-      }
-      function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
-        const workerErrors = workerEvents.filter((event) => event.type === master_1.WorkerEventType.internalError).map((errorEvent) => errorEvent.error);
-        return Object.assign(raw, {
-          [symbols_1.$errors]: workerErrors,
-          [symbols_1.$events]: workerEvents,
-          [symbols_1.$terminate]: terminate,
-          [symbols_1.$worker]: worker
-        });
-      }
-      async function spawn(worker, options) {
-        debugSpawn("Initializing new thread");
-        const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
-        const initMessage = await withTimeout(receiveInitMessage(worker), timeout, `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`);
-        const exposed = initMessage.exposed;
-        const { termination, terminate } = createTerminator(worker);
-        const events = createEventObservable(worker, termination);
-        if (exposed.type === "function") {
-          const proxy = (0, invocation_proxy_1.createProxyFunction)(worker);
-          return setPrivateThreadProps(proxy, worker, events, terminate);
-        } else if (exposed.type === "module") {
-          const proxy = (0, invocation_proxy_1.createProxyModule)(worker, exposed.methods);
-          return setPrivateThreadProps(proxy, worker, events, terminate);
-        } else {
-          const type = exposed.type;
-          throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
-        }
-      }
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/index.js
-  var require_master2 = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/master/index.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.isWorkerRuntime = exports.Worker = exports.BlobWorker = exports.Thread = exports.spawn = exports.Pool = void 0;
-      var implementation_1 = require_implementation_browser();
-      var pool_1 = require_pool();
-      Object.defineProperty(exports, "Pool", { enumerable: true, get: function() {
-        return pool_1.Pool;
-      } });
-      var spawn_1 = require_spawn();
-      Object.defineProperty(exports, "spawn", { enumerable: true, get: function() {
-        return spawn_1.spawn;
-      } });
-      var thread_1 = require_thread();
-      Object.defineProperty(exports, "Thread", { enumerable: true, get: function() {
-        return thread_1.Thread;
-      } });
-      exports.BlobWorker = (0, implementation_1.getWorkerImplementation)().blob;
-      exports.Worker = (0, implementation_1.getWorkerImplementation)().default;
-      var implementation_2 = require_implementation_browser();
-      Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function() {
-        return implementation_2.isWorkerRuntime;
-      } });
-    }
-  });
 
   // ../../../../../../node_modules/.store/is-observable-npm-2.1.0-f5cc32df88/package/index.js
-  var require_package3 = __commonJS({
+  var require_package = __commonJS({
     "../../../../../../node_modules/.store/is-observable-npm-2.1.0-f5cc32df88/package/index.js"(exports, module) {
       "use strict";
       module.exports = (value) => {
@@ -2633,257 +45,7 @@
     }
   });
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/worker/implementation.browser.js
-  var require_implementation_browser2 = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/worker/implementation.browser.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      var isWorkerRuntime = 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) {
-        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/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/worker/index.js
-  var require_worker = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/worker/index.js"(exports) {
-      "use strict";
-      var __importDefault = exports && exports.__importDefault || function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
-      exports.expose = expose2;
-      var is_observable_2_1_0_1 = __importDefault(require_package3());
-      var common_1 = require_common();
-      var transferable_1 = require_transferable();
-      var messages_1 = require_messages();
-      var implementation_1 = __importDefault(require_implementation_browser2());
-      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) => (0, is_observable_2_1_0_1.default)(thing) || isZenObservable(thing);
-      function isZenObservable(thing) {
-        return thing && typeof thing === "object" && typeof thing.subscribe === "function";
-      }
-      function deconstructTransfer(thing) {
-        return (0, transferable_1.isTransferDescriptor)(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
-      }
-      function postFunctionInitMessage() {
-        const initMessage = {
-          exposed: { type: "function" },
-          type: messages_1.WorkerMessageType.init
-        };
-        implementation_1.default.postMessageToMaster(initMessage);
-      }
-      function postModuleInitMessage(methodNames) {
-        const initMessage = {
-          exposed: {
-            methods: methodNames,
-            type: "module"
-          },
-          type: messages_1.WorkerMessageType.init
-        };
-        implementation_1.default.postMessageToMaster(initMessage);
-      }
-      function postJobErrorMessage(uid, rawError) {
-        const { payload: error, transferables } = deconstructTransfer(rawError);
-        const errorMessage = {
-          error: (0, common_1.serialize)(error),
-          type: messages_1.WorkerMessageType.error,
-          uid
-        };
-        implementation_1.default.postMessageToMaster(errorMessage, transferables);
-      }
-      function postJobResultMessage(uid, completed, resultValue) {
-        const { payload, transferables } = deconstructTransfer(resultValue);
-        const resultMessage = {
-          complete: completed ? true : void 0,
-          payload,
-          type: messages_1.WorkerMessageType.result,
-          uid
-        };
-        implementation_1.default.postMessageToMaster(resultMessage, transferables);
-      }
-      function postJobStartMessage(uid, resultType) {
-        const startMessage = {
-          resultType,
-          type: messages_1.WorkerMessageType.running,
-          uid
-        };
-        implementation_1.default.postMessageToMaster(startMessage);
-      }
-      function postUncaughtErrorMessage(error) {
-        try {
-          const errorMessage = {
-            error: (0, common_1.serialize)(error),
-            type: messages_1.WorkerMessageType.uncaughtError
-          };
-          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);
-        }
-      }
-      async function runFunction(jobUID, fn, args) {
-        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, (0, common_1.serialize)(value)), (error) => {
-            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
-            activeSubscriptions.delete(jobUID);
-          }, () => {
-            postJobResultMessage(jobUID, true);
-            activeSubscriptions.delete(jobUID);
-          });
-          activeSubscriptions.set(jobUID, subscription);
-        } else {
-          try {
-            const result = await syncResult;
-            postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
-          } catch (error) {
-            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
-          }
-        }
-      }
-      function expose2(exposed) {
-        if (!implementation_1.default.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_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 new 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);
-            }
-          }
-        });
-      }
-      if (typeof globalThis !== "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/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/index.js
-  var require_esm = __commonJS({
-    "../../../../../../node_modules/.store/@xylabs-threads-npm-4.6.4-a1d6b1bc6f/package/dist/esm/index.js"(exports) {
-      "use strict";
-      var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-        if (k2 === void 0) k2 = k;
-        var desc = Object.getOwnPropertyDescriptor(m, k);
-        if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-          desc = { enumerable: true, get: function() {
-            return m[k];
-          } };
-        }
-        Object.defineProperty(o, k2, desc);
-      } : function(o, m, k, k2) {
-        if (k2 === void 0) k2 = k;
-        o[k2] = m[k];
-      });
-      var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
-      };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.expose = exports.Transfer = exports.DefaultSerializer = exports.registerSerializer = void 0;
-      var common_1 = require_common();
-      Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function() {
-        return common_1.registerSerializer;
-      } });
-      __exportStar(require_master2(), exports);
-      var serializers_1 = require_serializers();
-      Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function() {
-        return serializers_1.DefaultSerializer;
-      } });
-      var transferable_1 = require_transferable();
-      Object.defineProperty(exports, "Transfer", { enumerable: true, get: function() {
-        return transferable_1.Transfer;
-      } });
-      var index_1 = require_worker();
-      Object.defineProperty(exports, "expose", { enumerable: true, get: function() {
-        return index_1.expose;
-      } });
-    }
-  });
-
-  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.6.4-6b7cd7d233/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-hex-npm-4.7.2-c461cca15a/package/dist/neutral/index.mjs
   var assertError = (value, assert, defaultMessage) => {
     if (assert) {
       const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
@@ -2939,8 +101,245 @@
     return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
   }
 
-  // src/worker/wasmHash.ts
-  var import_threads = __toESM(require_esm(), 1);
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-4.7.2-ddf7b4e71d/package/dist/browser/worker/worker.browser.mjs
+  var import_is_observable_2_1_0 = __toESM(require_package(), 1);
+  var DefaultErrorSerializer = {
+    deserialize(message) {
+      return Object.assign(new 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";
+  var DefaultSerializer = {
+    deserialize(message) {
+      return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
+    },
+    serialize(input) {
+      return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
+    }
+  };
+  globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function deserialize(message) {
+    return globalThis.registeredSerializer.deserialize(message);
+  }
+  function serialize(input) {
+    return globalThis.registeredSerializer.serialize(input);
+  }
+  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 isTransferDescriptor(thing) {
+    return thing && typeof thing === "object" && thing[$transferable];
+  }
+  var isErrorEvent = (value) => value && value.error;
+  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);
+    function isZenObservable(thing) {
+      return thing && 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) {
+            runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+          }
+        });
+        postFunctionInitMessage();
+      } else if (typeof exposed === "object" && exposed) {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method) {
+            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)) {
+          const jobUID = messageData.uid;
+          const subscription = activeSubscriptions.get(jobUID);
+          if (subscription) {
+            subscription.unsubscribe();
+            activeSubscriptions.delete(jobUID);
+          }
+        }
+      });
+    };
+    if (typeof globalThis !== "undefined" && typeof self2.addEventListener === "function" && implementation.isWorkerRuntime()) {
+      self2.addEventListener("error", (event) => {
+        setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
+      });
+      self2.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.isWorkerRuntime()) {
+      process.on("uncaughtException", (error) => {
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+      });
+      process.on("unhandledRejection", (error) => {
+        if (error && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    }
+    return expose2;
+  }
+  var isWorkerRuntime = 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) {
+    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;
+  };
+  var addEventListener = self.addEventListener;
+  var postMessage = self.postMessage;
+  var removeEventListener = self.removeEventListener;
+  var expose = createExpose({
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages
+  }, {
+    addEventListener,
+    postMessage,
+    removeEventListener
+  });
 
   // ../../../../../../node_modules/.store/hash-wasm-npm-4.12.0-d6bb202626/package/dist/index.esm.js
   function __awaiter(thisArg, _arguments, P, generator) {
@@ -3331,7 +730,7 @@
   var mutex = new Mutex();
 
   // src/worker/wasmHash.ts
-  (0, import_threads.expose)({
+  expose({
     async hash(data) {
       return asHash(await sha256(data), true);
     }