@xyo-network/sdk 2.102.4 → 7.0.3

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

@@ -0,0 +1,1678 @@
+"use strict";
+(() => {
+  // ../../../../../../node_modules/.pnpm/@xylabs+sdk@7.0.1_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@opentel_5cda832fbcd9b26c711a930815db0b42/node_modules/@xylabs/sdk/dist/_pkg/typeof/neutral/index.mjs
+  function isUndefined(value) {
+    return value === void 0;
+  }
+  function isString(value) {
+    return typeof value === "string";
+  }
+  function isNumber(value) {
+    return typeof value === "number";
+  }
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
+  var _a;
+  // @__NO_SIDE_EFFECTS__
+  function $constructor(name, initializer2, params) {
+    function init(inst, def) {
+      if (!inst._zod) {
+        Object.defineProperty(inst, "_zod", {
+          value: {
+            def,
+            constr: _,
+            traits: /* @__PURE__ */ new Set()
+          },
+          enumerable: false
+        });
+      }
+      if (inst._zod.traits.has(name)) {
+        return;
+      }
+      inst._zod.traits.add(name);
+      initializer2(inst, def);
+      const proto = _.prototype;
+      const keys = Object.keys(proto);
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        if (!(k in inst)) {
+          inst[k] = proto[k].bind(inst);
+        }
+      }
+    }
+    const Parent = params?.Parent ?? Object;
+    class Definition extends Parent {
+    }
+    Object.defineProperty(Definition, "name", { value: name });
+    function _(def) {
+      var _a3;
+      const inst = params?.Parent ? new Definition() : this;
+      init(inst, def);
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
+      for (const fn of inst._zod.deferred) {
+        fn();
+      }
+      return inst;
+    }
+    Object.defineProperty(_, "init", { value: init });
+    Object.defineProperty(_, Symbol.hasInstance, {
+      value: (inst) => {
+        if (params?.Parent && inst instanceof params.Parent)
+          return true;
+        return inst?._zod?.traits?.has(name);
+      }
+    });
+    Object.defineProperty(_, "name", { value: name });
+    return _;
+  }
+  var $ZodAsyncError = class extends Error {
+    constructor() {
+      super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+    }
+  };
+  var $ZodEncodeError = class extends Error {
+    constructor(name) {
+      super(`Encountered unidirectional transform during encode: ${name}`);
+      this.name = "ZodEncodeError";
+    }
+  };
+  (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+  var globalConfig = globalThis.__zod_globalConfig;
+  function config(newConfig) {
+    if (newConfig)
+      Object.assign(globalConfig, newConfig);
+    return globalConfig;
+  }
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/util.js
+  function jsonStringifyReplacer(_, value) {
+    if (typeof value === "bigint")
+      return value.toString();
+    return value;
+  }
+  function cleanRegex(source) {
+    const start = source.startsWith("^") ? 1 : 0;
+    const end = source.endsWith("$") ? source.length - 1 : source.length;
+    return source.slice(start, end);
+  }
+  var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
+  function defineLazy(object, key, getter) {
+    let value = void 0;
+    Object.defineProperty(object, key, {
+      get() {
+        if (value === EVALUATING) {
+          return void 0;
+        }
+        if (value === void 0) {
+          value = EVALUATING;
+          value = getter();
+        }
+        return value;
+      },
+      set(v) {
+        Object.defineProperty(object, key, {
+          value: v
+          // configurable: true,
+        });
+      },
+      configurable: true
+    });
+  }
+  var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
+  };
+  function clone(inst, def, params) {
+    const cl = new inst._zod.constr(def ?? inst._zod.def);
+    if (!def || params?.parent)
+      cl._zod.parent = inst;
+    return cl;
+  }
+  function normalizeParams(_params) {
+    const params = _params;
+    if (!params)
+      return {};
+    if (typeof params === "string")
+      return { error: () => params };
+    if (params?.message !== void 0) {
+      if (params?.error !== void 0)
+        throw new Error("Cannot specify both `message` and `error` params");
+      params.error = params.message;
+    }
+    delete params.message;
+    if (typeof params.error === "string")
+      return { ...params, error: () => params.error };
+    return params;
+  }
+  var NUMBER_FORMAT_RANGES = {
+    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    float32: [-34028234663852886e22, 34028234663852886e22],
+    float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+  };
+  function aborted(x, startIndex = 0) {
+    if (x.aborted === true)
+      return true;
+    for (let i = startIndex; i < x.issues.length; i++) {
+      if (x.issues[i]?.continue !== true) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function explicitlyAborted(x, startIndex = 0) {
+    if (x.aborted === true)
+      return true;
+    for (let i = startIndex; i < x.issues.length; i++) {
+      if (x.issues[i]?.continue === false) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function unwrapMessage(message) {
+    return typeof message === "string" ? message : message?.message;
+  }
+  function finalizeIssue(iss, ctx, config2) {
+    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
+    rest.path ?? (rest.path = []);
+    rest.message = message;
+    if (ctx?.reportInput) {
+      rest.input = _input;
+    }
+    return rest;
+  }
+  function issue(...args) {
+    const [iss, input, inst] = args;
+    if (typeof iss === "string") {
+      return {
+        message: iss,
+        code: "custom",
+        input,
+        inst
+      };
+    }
+    return { ...iss };
+  }
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/errors.js
+  var initializer = (inst, def) => {
+    inst.name = "$ZodError";
+    Object.defineProperty(inst, "_zod", {
+      value: inst._zod,
+      enumerable: false
+    });
+    Object.defineProperty(inst, "issues", {
+      value: def,
+      enumerable: false
+    });
+    inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+    Object.defineProperty(inst, "toString", {
+      value: () => inst.message,
+      enumerable: false
+    });
+  };
+  var $ZodError = $constructor("$ZodError", initializer);
+  var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/parse.js
+  var _parse = (_Err) => (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+      throw new $ZodAsyncError();
+    }
+    if (result.issues.length) {
+      const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      captureStackTrace(e, _params?.callee);
+      throw e;
+    }
+    return result.value;
+  };
+  var parse = /* @__PURE__ */ _parse($ZodRealError);
+  var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+      result = await result;
+    if (result.issues.length) {
+      const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      captureStackTrace(e, params?.callee);
+      throw e;
+    }
+    return result.value;
+  };
+  var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+  var _safeParse = (_Err) => (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+      throw new $ZodAsyncError();
+    }
+    return result.issues.length ? {
+      success: false,
+      error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    } : { success: true, data: result.value };
+  };
+  var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+  var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+      result = await result;
+    return result.issues.length ? {
+      success: false,
+      error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    } : { success: true, data: result.value };
+  };
+  var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/regexes.js
+  var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+  var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+  var string = (params) => {
+    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+    return new RegExp(`^${regex}$`);
+  };
+  var bigint = /^-?\d+n?$/;
+  var number = /^-?\d+(?:\.\d+)?$/;
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/checks.js
+  var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+    var _a3;
+    inst._zod ?? (inst._zod = {});
+    inst._zod.def = def;
+    (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
+  });
+  var numericOriginMap = {
+    number: "number",
+    bigint: "bigint",
+    object: "date"
+  };
+  var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+    $ZodCheck.init(inst, def);
+    const origin = numericOriginMap[typeof def.value];
+    inst._zod.onattach.push((inst2) => {
+      const bag = inst2._zod.bag;
+      const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+      if (def.value > curr) {
+        if (def.inclusive)
+          bag.minimum = def.value;
+        else
+          bag.exclusiveMinimum = def.value;
+      }
+    });
+    inst._zod.check = (payload) => {
+      if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+        return;
+      }
+      payload.issues.push({
+        origin,
+        code: "too_small",
+        minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+        input: payload.value,
+        inclusive: def.inclusive,
+        inst,
+        continue: !def.abort
+      });
+    };
+  });
+  var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+    var _a3, _b;
+    $ZodCheck.init(inst, def);
+    inst._zod.onattach.push((inst2) => {
+      const bag = inst2._zod.bag;
+      bag.format = def.format;
+      if (def.pattern) {
+        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+        bag.patterns.add(def.pattern);
+      }
+    });
+    if (def.pattern)
+      (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
+        def.pattern.lastIndex = 0;
+        if (def.pattern.test(payload.value))
+          return;
+        payload.issues.push({
+          origin: "string",
+          code: "invalid_format",
+          format: def.format,
+          input: payload.value,
+          ...def.pattern ? { pattern: def.pattern.toString() } : {},
+          inst,
+          continue: !def.abort
+        });
+      });
+    else
+      (_b = inst._zod).check ?? (_b.check = () => {
+      });
+  });
+  var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+    $ZodCheckStringFormat.init(inst, def);
+    inst._zod.check = (payload) => {
+      def.pattern.lastIndex = 0;
+      if (def.pattern.test(payload.value))
+        return;
+      payload.issues.push({
+        origin: "string",
+        code: "invalid_format",
+        format: "regex",
+        input: payload.value,
+        pattern: def.pattern.toString(),
+        inst,
+        continue: !def.abort
+      });
+    };
+  });
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/versions.js
+  var version = {
+    major: 4,
+    minor: 4,
+    patch: 3
+  };
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/schemas.js
+  var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+    var _a3;
+    inst ?? (inst = {});
+    inst._zod.def = def;
+    inst._zod.bag = inst._zod.bag || {};
+    inst._zod.version = version;
+    const checks = [...inst._zod.def.checks ?? []];
+    if (inst._zod.traits.has("$ZodCheck")) {
+      checks.unshift(inst);
+    }
+    for (const ch of checks) {
+      for (const fn of ch._zod.onattach) {
+        fn(inst);
+      }
+    }
+    if (checks.length === 0) {
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
+      inst._zod.deferred?.push(() => {
+        inst._zod.run = inst._zod.parse;
+      });
+    } else {
+      const runChecks = (payload, checks2, ctx) => {
+        let isAborted = aborted(payload);
+        let asyncResult;
+        for (const ch of checks2) {
+          if (ch._zod.def.when) {
+            if (explicitlyAborted(payload))
+              continue;
+            const shouldRun = ch._zod.def.when(payload);
+            if (!shouldRun)
+              continue;
+          } else if (isAborted) {
+            continue;
+          }
+          const currLen = payload.issues.length;
+          const _ = ch._zod.check(payload);
+          if (_ instanceof Promise && ctx?.async === false) {
+            throw new $ZodAsyncError();
+          }
+          if (asyncResult || _ instanceof Promise) {
+            asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+              await _;
+              const nextLen = payload.issues.length;
+              if (nextLen === currLen)
+                return;
+              if (!isAborted)
+                isAborted = aborted(payload, currLen);
+            });
+          } else {
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              continue;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          }
+        }
+        if (asyncResult) {
+          return asyncResult.then(() => {
+            return payload;
+          });
+        }
+        return payload;
+      };
+      const handleCanaryResult = (canary, payload, ctx) => {
+        if (aborted(canary)) {
+          canary.aborted = true;
+          return canary;
+        }
+        const checkResult = runChecks(payload, checks, ctx);
+        if (checkResult instanceof Promise) {
+          if (ctx.async === false)
+            throw new $ZodAsyncError();
+          return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+        }
+        return inst._zod.parse(checkResult, ctx);
+      };
+      inst._zod.run = (payload, ctx) => {
+        if (ctx.skipChecks) {
+          return inst._zod.parse(payload, ctx);
+        }
+        if (ctx.direction === "backward") {
+          const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+          if (canary instanceof Promise) {
+            return canary.then((canary2) => {
+              return handleCanaryResult(canary2, payload, ctx);
+            });
+          }
+          return handleCanaryResult(canary, payload, ctx);
+        }
+        const result = inst._zod.parse(payload, ctx);
+        if (result instanceof Promise) {
+          if (ctx.async === false)
+            throw new $ZodAsyncError();
+          return result.then((result2) => runChecks(result2, checks, ctx));
+        }
+        return runChecks(result, checks, ctx);
+      };
+    }
+    defineLazy(inst, "~standard", () => ({
+      validate: (value) => {
+        try {
+          const r = safeParse(inst, value);
+          return r.success ? { value: r.data } : { issues: r.error?.issues };
+        } catch (_) {
+          return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+        }
+      },
+      vendor: "zod",
+      version: 1
+    }));
+  });
+  var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+    inst._zod.parse = (payload, _) => {
+      if (def.coerce)
+        try {
+          payload.value = String(payload.value);
+        } catch (_2) {
+        }
+      if (typeof payload.value === "string")
+        return payload;
+      payload.issues.push({
+        expected: "string",
+        code: "invalid_type",
+        input: payload.value,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = inst._zod.bag.pattern ?? number;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = Number(payload.value);
+        } catch (_) {
+        }
+      const input = payload.value;
+      if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+        return payload;
+      }
+      const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+      payload.issues.push({
+        expected: "number",
+        code: "invalid_type",
+        input,
+        inst,
+        ...received ? { received } : {}
+      });
+      return payload;
+    };
+  });
+  var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = bigint;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = BigInt(payload.value);
+        } catch (_) {
+        }
+      if (typeof payload.value === "bigint")
+        return payload;
+      payload.issues.push({
+        expected: "bigint",
+        code: "invalid_type",
+        input: payload.value,
+        inst
+      });
+      return payload;
+    };
+  });
+  function handleUnionResults(results, final, inst, ctx) {
+    for (const result of results) {
+      if (result.issues.length === 0) {
+        final.value = result.value;
+        return final;
+      }
+    }
+    const nonaborted = results.filter((r) => !aborted(r));
+    if (nonaborted.length === 1) {
+      final.value = nonaborted[0].value;
+      return nonaborted[0];
+    }
+    final.issues.push({
+      code: "invalid_union",
+      input: final.value,
+      inst,
+      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    });
+    return final;
+  }
+  var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+    $ZodType.init(inst, def);
+    defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+    defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+    defineLazy(inst._zod, "values", () => {
+      if (def.options.every((o) => o._zod.values)) {
+        return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+      }
+      return void 0;
+    });
+    defineLazy(inst._zod, "pattern", () => {
+      if (def.options.every((o) => o._zod.pattern)) {
+        const patterns = def.options.map((o) => o._zod.pattern);
+        return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+      }
+      return void 0;
+    });
+    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
+    inst._zod.parse = (payload, ctx) => {
+      if (first) {
+        return first(payload, ctx);
+      }
+      let async = false;
+      const results = [];
+      for (const option of def.options) {
+        const result = option._zod.run({
+          value: payload.value,
+          issues: []
+        }, ctx);
+        if (result instanceof Promise) {
+          results.push(result);
+          async = true;
+        } else {
+          if (result.issues.length === 0)
+            return result;
+          results.push(result);
+        }
+      }
+      if (!async)
+        return handleUnionResults(results, payload, inst, ctx);
+      return Promise.all(results).then((results2) => {
+        return handleUnionResults(results2, payload, inst, ctx);
+      });
+    };
+  });
+  var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.optin = "optional";
+    inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        throw new $ZodEncodeError(inst.constructor.name);
+      }
+      const _out = def.transform(payload.value, payload);
+      if (ctx.async) {
+        const output = _out instanceof Promise ? _out : Promise.resolve(_out);
+        return output.then((output2) => {
+          payload.value = output2;
+          payload.fallback = true;
+          return payload;
+        });
+      }
+      if (_out instanceof Promise) {
+        throw new $ZodAsyncError();
+      }
+      payload.value = _out;
+      payload.fallback = true;
+      return payload;
+    };
+  });
+  var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+    $ZodType.init(inst, def);
+    defineLazy(inst._zod, "values", () => def.in._zod.values);
+    defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+    defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+    defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+    inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        const right = def.out._zod.run(payload, ctx);
+        if (right instanceof Promise) {
+          return right.then((right2) => handlePipeResult(right2, def.in, ctx));
+        }
+        return handlePipeResult(right, def.in, ctx);
+      }
+      const left = def.in._zod.run(payload, ctx);
+      if (left instanceof Promise) {
+        return left.then((left2) => handlePipeResult(left2, def.out, ctx));
+      }
+      return handlePipeResult(left, def.out, ctx);
+    };
+  });
+  function handlePipeResult(left, next, ctx) {
+    if (left.issues.length) {
+      left.aborted = true;
+      return left;
+    }
+    return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
+  }
+  var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+    $ZodCheck.init(inst, def);
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _) => {
+      return payload;
+    };
+    inst._zod.check = (payload) => {
+      const input = payload.value;
+      const r = def.fn(input);
+      if (r instanceof Promise) {
+        return r.then((r2) => handleRefineResult(r2, payload, input, inst));
+      }
+      handleRefineResult(r, payload, input, inst);
+      return;
+    };
+  });
+  function handleRefineResult(result, payload, input, inst) {
+    if (!result) {
+      const _iss = {
+        code: "custom",
+        input,
+        inst,
+        // incorporates params.error into issue reporting
+        path: [...inst._zod.def.path ?? []],
+        // incorporates params.error into issue reporting
+        continue: !inst._zod.def.abort
+        // params: inst._zod.def.params,
+      };
+      if (inst._zod.def.params)
+        _iss.params = inst._zod.def.params;
+      payload.issues.push(issue(_iss));
+    }
+  }
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/api.js
+  // @__NO_SIDE_EFFECTS__
+  function _string(Class, params) {
+    return new Class({
+      type: "string",
+      ...normalizeParams(params)
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _number(Class, params) {
+    return new Class({
+      type: "number",
+      checks: [],
+      ...normalizeParams(params)
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _bigint(Class, params) {
+    return new Class({
+      type: "bigint",
+      ...normalizeParams(params)
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _gte(value, params) {
+    return new $ZodCheckGreaterThan({
+      check: "greater_than",
+      ...normalizeParams(params),
+      value,
+      inclusive: true
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _nonnegative(params) {
+    return /* @__PURE__ */ _gte(0, params);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _regex(pattern, params) {
+    return new $ZodCheckRegex({
+      check: "string_format",
+      format: "regex",
+      ...normalizeParams(params),
+      pattern
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _refine(Class, fn, _params) {
+    const schema = new Class({
+      type: "custom",
+      check: "custom",
+      fn,
+      ...normalizeParams(_params)
+    });
+    return schema;
+  }
+
+  // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/mini/schemas.js
+  var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+    if (!inst._zod)
+      throw new Error("Uninitialized schema in ZodMiniType.");
+    $ZodType.init(inst, def);
+    inst.def = def;
+    inst.type = def.type;
+    inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+    inst.safeParse = (data, params) => safeParse(inst, data, params);
+    inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+    inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+    inst.check = (...checks) => {
+      return inst.clone({
+        ...def,
+        checks: [
+          ...def.checks ?? [],
+          ...checks.map((ch) => typeof ch === "function" ? {
+            _zod: { check: ch, def: { check: "custom" }, onattach: [] }
+          } : ch)
+        ]
+      }, { parent: true });
+    };
+    inst.with = inst.check;
+    inst.clone = (_def, params) => clone(inst, _def, params);
+    inst.brand = () => inst;
+    inst.register = ((reg, meta2) => {
+      reg.add(inst, meta2);
+      return inst;
+    });
+    inst.apply = (fn) => fn(inst);
+  });
+  var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+    $ZodString.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function string2(params) {
+    return _string(ZodMiniString, params);
+  }
+  var ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+    $ZodNumber.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function number2(params) {
+    return _number(ZodMiniNumber, params);
+  }
+  var ZodMiniBigInt = /* @__PURE__ */ $constructor("ZodMiniBigInt", (inst, def) => {
+    $ZodBigInt.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function bigint2(params) {
+    return _bigint(ZodMiniBigInt, params);
+  }
+  var ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+    $ZodUnion.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function union(options, params) {
+    return new ZodMiniUnion({
+      type: "union",
+      options,
+      ...normalizeParams(params)
+    });
+  }
+  var ZodMiniTransform = /* @__PURE__ */ $constructor("ZodMiniTransform", (inst, def) => {
+    $ZodTransform.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function transform(fn) {
+    return new ZodMiniTransform({
+      type: "transform",
+      transform: fn
+    });
+  }
+  var ZodMiniPipe = /* @__PURE__ */ $constructor("ZodMiniPipe", (inst, def) => {
+    $ZodPipe.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function pipe(in_, out) {
+    return new ZodMiniPipe({
+      type: "pipe",
+      in: in_,
+      out
+    });
+  }
+  var ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+    $ZodCustom.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function refine(fn, _params = {}) {
+    return _refine(ZodMiniCustom, fn, _params);
+  }
+
+  // ../../../../../../node_modules/.pnpm/@xylabs+sdk@7.0.1_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@opentel_5cda832fbcd9b26c711a930815db0b42/node_modules/@xylabs/sdk/dist/_pkg/error/neutral/index.mjs
+  var assertError = (value, assert, defaultMessage) => {
+    if (!isUndefined(assert)) {
+      const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+      if (isString(assertString) || assertString) {
+        throw new Error(assertString === true ? defaultMessage : assertString);
+      }
+    }
+    return void 0;
+  };
+
+  // ../../../../../../node_modules/.pnpm/@xylabs+sdk@7.0.1_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@opentel_5cda832fbcd9b26c711a930815db0b42/node_modules/@xylabs/sdk/dist/_pkg/hex/neutral/index.mjs
+  var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+    return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+  };
+  var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+    return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+  };
+  var HexRegEx = /^[0-9a-f]+$/;
+  var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+  var ADDRESS_LENGTH = 40;
+  var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+  var AddressZod = pipe(
+    string2().check(_regex(AddressRegEx)),
+    transform((v) => v)
+  );
+  var bitsToNibbles = (value) => {
+    const nibbles = value >> 2;
+    if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+    return nibbles;
+  };
+  var isHex = (value, config2) => {
+    if (typeof value !== "string") return false;
+    const valueCharLength = value.length - (config2?.prefix === true ? 2 : 0);
+    if (config2?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config2?.bitLength)) return false;
+    const regex5 = config2?.prefix === true ? HexRegExWithPrefix : HexRegEx;
+    return regex5.test(value);
+  };
+  var hexFromHexString = (value, config2 = {}) => {
+    const {
+      prefix: isPrefix = false,
+      byteSize = 8,
+      bitLength
+    } = config2;
+    const nibbleBoundary = bitsToNibbles(byteSize);
+    const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+    if (isHex(unEvened)) {
+      const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
+      const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+      return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+    }
+    throw new Error("Received string is not a value hex");
+  };
+  var hexFromArrayBuffer = (buffer, config2) => {
+    const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+    return hexFromHexString(unPadded, config2);
+  };
+  var hexFromBigInt = (value, config2 = {}) => {
+    const unPadded = value.toString(16);
+    return hexFromHexString(unPadded, config2);
+  };
+  var hexFromNumber = (value, config2) => {
+    return hexFromBigInt(BigInt(value), config2);
+  };
+  var hexFrom = (value, config2) => {
+    switch (typeof value) {
+      case "string": {
+        return hexFromHexString(value, config2);
+      }
+      case "bigint": {
+        return hexFromBigInt(value, config2);
+      }
+      case "number": {
+        return hexFromNumber(value, config2);
+      }
+      case "object": {
+        return hexFromArrayBuffer(value, config2);
+      }
+      default: {
+        throw new Error(`Invalid type: ${typeof value}`);
+      }
+    }
+  };
+  var HexZod = pipe(
+    string2().check(_regex(HexRegEx, { error: "Invalid hex format" })),
+    transform((val) => val)
+  );
+  var toHex = (value, config2 = {}) => {
+    const { prefix: isPrefix = false } = config2;
+    return hexFrom(value, { prefix: isPrefix, ...config2 });
+  };
+  var AddressValidationZod = pipe(
+    string2().check(
+      refine((x) => HexZod.safeParse(x).success),
+      refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
+    ),
+    transform((v) => v)
+  );
+  var AddressTransformZod = pipe(
+    pipe(
+      union([string2(), bigint2(), number2()]),
+      transform((value) => {
+        if (typeof value === "bigint") {
+          return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+        }
+        if (typeof value === "string") {
+          return value.startsWith("0x") ? value.slice(2) : value;
+        }
+        return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+      })
+    ).check(refine((x) => AddressValidationZod.safeParse(x).success)),
+    transform((x) => x)
+  );
+  var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+  var EthAddressToStringZod = string2().check(_regex(EthAddressRegEx));
+  var EthAddressFromStringZod = pipe(
+    string2().check(_regex(EthAddressRegEx)),
+    transform((v) => toEthAddress(v))
+  );
+  var toEthAddress = (value, config2 = {}) => {
+    const { bitLength = 160, prefix: isPrefix = false } = config2;
+    return `0x${hexFrom(value, {
+      bitLength,
+      prefix: isPrefix,
+      ...config2
+    })}`;
+  };
+  var isEthAddress = (value, config2 = {}) => {
+    const { bitLength = 160, prefix: isPrefix = true } = config2;
+    const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+    return isHex(loweredValue, { bitLength, prefix: isPrefix });
+  };
+  var EthAddressZod = string2().check(
+    _regex(EthAddressRegEx, { error: "Invalid address format" }),
+    refine(isEthAddress)
+  );
+  var isHash = (value, bitLength = 256) => {
+    return isHex(value, { bitLength });
+  };
+  function asHash(value, assert) {
+    switch (typeof value) {
+      case "string": {
+        const stringValue = hexFromHexString(value);
+        return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+      }
+      default: {
+        return isUndefined(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+      }
+    }
+  }
+  var HASH_LENGTH = 32;
+  var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+  var HashZod = pipe(
+    string2().check(_regex(HashRegEx, { error: "Invalid hex format" })),
+    transform((val) => val)
+  );
+  var HashToJsonZod = pipe(HashZod, transform((v) => v));
+  var JsonToHashZod = pipe(string2(), transform((v) => asHash(v, true)));
+  function hexToBigInt(hex) {
+    return BigInt(hexFromHexString(hex, { prefix: true }));
+  }
+  var BigIntToJsonZod = pipe(
+    bigint2().check(_nonnegative()),
+    transform((x) => toHex(x))
+  );
+  var JsonToBigIntZod = pipe(
+    string2(),
+    transform((x) => hexToBigInt(toHex(x)))
+  );
+
+  // ../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.1_debug@4.4.3_observable-fns@0.6.1/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs
+  var DefaultErrorSerializer = {
+    deserialize: (message) => {
+      const error = Object.create(Error.prototype);
+      error.message = message.message;
+      error.name = message.name;
+      error.stack = message.stack;
+      return error;
+    },
+    serialize: (error) => ({
+      __error_marker: "$$error",
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    })
+  };
+  var isSerializedError = (thing) => thing != null && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var DefaultSerializer = {
+    deserialize: (message) => isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message,
+    serialize: (input) => 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 isSomeObservable = (value) => {
+    if (value == null) {
+      return false;
+    }
+    if (typeof Symbol.observable === "symbol" && typeof value[Symbol.observable] === "function") {
+      return value === value[Symbol.observable]();
+    }
+    if (typeof value["@@observable"] === "function") {
+      return value === value["@@observable"]();
+    }
+    return false;
+  };
+  var $transferable = /* @__PURE__ */ Symbol("thread.transferable");
+  function isTransferDescriptor(thing) {
+    return thing != null && typeof thing === "object" && Reflect.get(thing, $transferable) === true;
+  }
+  var isErrorEvent = (value) => value !== void 0 && value.error !== void 0;
+  function createExpose(implementation, self2) {
+    let exposeCalled = false;
+    const activeSubscriptions = /* @__PURE__ */ new Map();
+    const isMasterJobCancelMessage = (thing) => thing?.type === "cancel";
+    const isMasterJobRunMessage = (thing) => thing?.type === "run";
+    const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
+    function isZenObservable(thing) {
+      return thing != null && typeof thing === "object" && typeof thing.subscribe === "function";
+    }
+    function deconstructTransfer(thing) {
+      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+    }
+    function postFunctionInitMessage() {
+      const initMessage = {
+        exposed: { type: "function" },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postModuleInitMessage(methodNames) {
+      const initMessage = {
+        exposed: {
+          methods: methodNames,
+          type: "module"
+        },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postJobErrorMessage(uid, rawError) {
+      const { payload: error, transferables } = deconstructTransfer(rawError);
+      const errorMessage = {
+        error: serialize(error),
+        type: "error",
+        uid
+      };
+      implementation.postMessageToMaster(errorMessage, transferables);
+    }
+    function postJobResultMessage(uid, completed, resultValue) {
+      const { payload, transferables } = deconstructTransfer(resultValue);
+      const resultMessage = {
+        complete: completed ? true : void 0,
+        payload,
+        type: "result",
+        uid
+      };
+      implementation.postMessageToMaster(resultMessage, transferables);
+    }
+    function postJobStartMessage(uid, resultType) {
+      const startMessage = {
+        resultType,
+        type: "running",
+        uid
+      };
+      implementation.postMessageToMaster(startMessage);
+    }
+    function postUncaughtErrorMessage(error) {
+      try {
+        const errorMessage = {
+          error: serialize(error),
+          type: "uncaughtError"
+          /* uncaughtError */
+        };
+        implementation.postMessageToMaster(errorMessage);
+      } catch (subError) {
+        console.error(
+          "Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:",
+          subError,
+          "\nOriginal error:",
+          error
+        );
+      }
+    }
+    async function runFunction(jobUID, fn, args) {
+      let syncResult;
+      try {
+        syncResult = fn(...args);
+      } catch (ex) {
+        const error = ex;
+        return postJobErrorMessage(jobUID, error);
+      }
+      const resultType = isObservable(syncResult) ? "observable" : "promise";
+      postJobStartMessage(jobUID, resultType);
+      if (isObservable(syncResult)) {
+        const subscription = syncResult.subscribe(
+          (value) => postJobResultMessage(jobUID, false, serialize(value)),
+          (error) => {
+            postJobErrorMessage(jobUID, serialize(error));
+            activeSubscriptions.delete(jobUID);
+          },
+          () => {
+            postJobResultMessage(jobUID, true);
+            activeSubscriptions.delete(jobUID);
+          }
+        );
+        activeSubscriptions.set(jobUID, subscription);
+      } else {
+        try {
+          const result = await syncResult;
+          postJobResultMessage(jobUID, true, serialize(result));
+        } catch (error) {
+          postJobErrorMessage(jobUID, serialize(error));
+        }
+      }
+    }
+    const expose2 = (exposed) => {
+      if (!implementation.isWorkerRuntime()) {
+        throw new Error("expose() called in the master thread.");
+      }
+      if (exposeCalled) {
+        throw new Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+      }
+      exposeCalled = true;
+      if (typeof exposed === "function") {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method === void 0) {
+            runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+          }
+        });
+        postFunctionInitMessage();
+      } else if (typeof exposed === "object" && exposed !== null) {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method !== void 0) {
+            runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+          }
+        });
+        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === "function");
+        postModuleInitMessage(methodNames);
+      } else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+      }
+      implementation.subscribeToMasterMessages((messageData) => {
+        if (!isMasterJobCancelMessage(messageData)) {
+          return;
+        }
+        const jobUID = messageData.uid;
+        const subscription = activeSubscriptions.get(jobUID);
+        if (subscription) {
+          subscription.unsubscribe();
+          activeSubscriptions.delete(jobUID);
+        }
+      });
+    };
+    const subscribeToBrowserUncaughtErrors = () => {
+      if (typeof globalThis === "undefined" || typeof self2.addEventListener !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      self2.addEventListener("error", (event) => {
+        setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
+      });
+      self2.addEventListener("unhandledrejection", (event) => {
+        const error = event.reason;
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    const subscribeToNodeUncaughtErrors = () => {
+      const nodeProcess = globalThis.process;
+      if (nodeProcess === void 0 || typeof nodeProcess.on !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      nodeProcess.on("uncaughtException", (error) => {
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+      });
+      nodeProcess.on("unhandledRejection", (error) => {
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    subscribeToBrowserUncaughtErrors();
+    subscribeToNodeUncaughtErrors();
+    return expose2;
+  }
+  var isWorkerRuntime = function isWorkerRuntime2() {
+    const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
+    return self?.postMessage !== void 0 && !isWindowContext;
+  };
+  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.bind(void 0);
+  var postMessage = self.postMessage.bind(void 0);
+  var removeEventListener = self.removeEventListener.bind(void 0);
+  var expose = createExpose({
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages
+  }, {
+    addEventListener,
+    postMessage,
+    removeEventListener
+  });
+
+  // ../../../../../../node_modules/.pnpm/hash-wasm@4.12.0/node_modules/hash-wasm/dist/index.esm.js
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  var Mutex = class {
+    constructor() {
+      this.mutex = Promise.resolve();
+    }
+    lock() {
+      let begin = () => {
+      };
+      this.mutex = this.mutex.then(() => new Promise(begin));
+      return new Promise((res) => {
+        begin = res;
+      });
+    }
+    dispatch(fn) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const unlock = yield this.lock();
+        try {
+          return yield Promise.resolve(fn());
+        } finally {
+          unlock();
+        }
+      });
+    }
+  };
+  var _a2;
+  function getGlobal() {
+    if (typeof globalThis !== "undefined")
+      return globalThis;
+    if (typeof self !== "undefined")
+      return self;
+    if (typeof window !== "undefined")
+      return window;
+    return global;
+  }
+  var globalObject = getGlobal();
+  var nodeBuffer = (_a2 = globalObject.Buffer) !== null && _a2 !== void 0 ? _a2 : null;
+  var textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
+  function hexCharCodesToInt(a, b) {
+    return (a & 15) + (a >> 6 | a >> 3 & 8) << 4 | (b & 15) + (b >> 6 | b >> 3 & 8);
+  }
+  function writeHexToUInt8(buf, str) {
+    const size = str.length >> 1;
+    for (let i = 0; i < size; i++) {
+      const index = i << 1;
+      buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+    }
+  }
+  function hexStringEqualsUInt8(str, buf) {
+    if (str.length !== buf.length * 2) {
+      return false;
+    }
+    for (let i = 0; i < buf.length; i++) {
+      const strIndex = i << 1;
+      if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var alpha = "a".charCodeAt(0) - 10;
+  var digit = "0".charCodeAt(0);
+  function getDigestHex(tmpBuffer, input, hashLength) {
+    let p = 0;
+    for (let i = 0; i < hashLength; i++) {
+      let nibble = input[i] >>> 4;
+      tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+      nibble = input[i] & 15;
+      tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+    }
+    return String.fromCharCode.apply(null, tmpBuffer);
+  }
+  var getUInt8Buffer = nodeBuffer !== null ? (data) => {
+    if (typeof data === "string") {
+      const buf = nodeBuffer.from(data, "utf8");
+      return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+    }
+    if (nodeBuffer.isBuffer(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.length);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    throw new Error("Invalid data type!");
+  } : (data) => {
+    if (typeof data === "string") {
+      return textEncoder.encode(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    throw new Error("Invalid data type!");
+  };
+  var base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var base64Lookup = new Uint8Array(256);
+  for (let i = 0; i < base64Chars.length; i++) {
+    base64Lookup[base64Chars.charCodeAt(i)] = i;
+  }
+  function getDecodeBase64Length(data) {
+    let bufferLength = Math.floor(data.length * 0.75);
+    const len = data.length;
+    if (data[len - 1] === "=") {
+      bufferLength -= 1;
+      if (data[len - 2] === "=") {
+        bufferLength -= 1;
+      }
+    }
+    return bufferLength;
+  }
+  function decodeBase64(data) {
+    const bufferLength = getDecodeBase64Length(data);
+    const len = data.length;
+    const bytes = new Uint8Array(bufferLength);
+    let p = 0;
+    for (let i = 0; i < len; i += 4) {
+      const encoded1 = base64Lookup[data.charCodeAt(i)];
+      const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+      const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+      const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+      bytes[p] = encoded1 << 2 | encoded2 >> 4;
+      p += 1;
+      bytes[p] = (encoded2 & 15) << 4 | encoded3 >> 2;
+      p += 1;
+      bytes[p] = (encoded3 & 3) << 6 | encoded4 & 63;
+      p += 1;
+    }
+    return bytes;
+  }
+  var MAX_HEAP = 16 * 1024;
+  var WASM_FUNC_HASH_LENGTH = 4;
+  var wasmMutex = new Mutex();
+  var wasmModuleCache = /* @__PURE__ */ new Map();
+  function WASMInterface(binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let wasmInstance = null;
+      let memoryView = null;
+      let initialized = false;
+      if (typeof WebAssembly === "undefined") {
+        throw new Error("WebAssembly is not supported in this environment!");
+      }
+      const writeMemory = (data, offset = 0) => {
+        memoryView.set(data, offset);
+      };
+      const getMemory = () => memoryView;
+      const getExports = () => wasmInstance.exports;
+      const setMemorySize = (totalSize) => {
+        wasmInstance.exports.Hash_SetMemorySize(totalSize);
+        const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+      };
+      const getStateSize = () => {
+        const view = new DataView(wasmInstance.exports.memory.buffer);
+        const stateSize = view.getUint32(wasmInstance.exports.STATE_SIZE, true);
+        return stateSize;
+      };
+      const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
+        if (!wasmModuleCache.has(binary.name)) {
+          const asm = decodeBase64(binary.data);
+          const promise = WebAssembly.compile(asm);
+          wasmModuleCache.set(binary.name, promise);
+        }
+        const module = yield wasmModuleCache.get(binary.name);
+        wasmInstance = yield WebAssembly.instantiate(module, {
+          // env: {
+          //   emscripten_memcpy_big: (dest, src, num) => {
+          //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+          //     const memView = new Uint8Array(memoryBuffer, 0);
+          //     memView.set(memView.subarray(src, src + num), dest);
+          //   },
+          //   print_memory: (offset, len) => {
+          //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+          //     const memView = new Uint8Array(memoryBuffer, 0);
+          //     console.log('print_int32', memView.subarray(offset, offset + len));
+          //   },
+          // },
+        });
+      }));
+      const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
+        if (!wasmInstance) {
+          yield loadWASMPromise;
+        }
+        const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+      });
+      const init = (bits = null) => {
+        initialized = true;
+        wasmInstance.exports.Hash_Init(bits);
+      };
+      const updateUInt8Array = (data) => {
+        let read = 0;
+        while (read < data.length) {
+          const chunk = data.subarray(read, read + MAX_HEAP);
+          read += chunk.length;
+          memoryView.set(chunk);
+          wasmInstance.exports.Hash_Update(chunk.length);
+        }
+      };
+      const update = (data) => {
+        if (!initialized) {
+          throw new Error("update() called before init()");
+        }
+        const Uint8Buffer = getUInt8Buffer(data);
+        updateUInt8Array(Uint8Buffer);
+      };
+      const digestChars = new Uint8Array(hashLength * 2);
+      const digest = (outputType, padding = null) => {
+        if (!initialized) {
+          throw new Error("digest() called before init()");
+        }
+        initialized = false;
+        wasmInstance.exports.Hash_Final(padding);
+        if (outputType === "binary") {
+          return memoryView.slice(0, hashLength);
+        }
+        return getDigestHex(digestChars, memoryView, hashLength);
+      };
+      const save = () => {
+        if (!initialized) {
+          throw new Error("save() can only be called after init() and before digest()");
+        }
+        const stateOffset = wasmInstance.exports.Hash_GetState();
+        const stateLength = getStateSize();
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+        const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+        writeHexToUInt8(prefixedState, binary.hash);
+        prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+        return prefixedState;
+      };
+      const load = (state) => {
+        if (!(state instanceof Uint8Array)) {
+          throw new Error("load() expects an Uint8Array generated by save()");
+        }
+        const stateOffset = wasmInstance.exports.Hash_GetState();
+        const stateLength = getStateSize();
+        const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
+        const memoryBuffer = wasmInstance.exports.memory.buffer;
+        if (state.length !== overallLength) {
+          throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+        }
+        if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
+          throw new Error("This state was written by an incompatible hash implementation");
+        }
+        const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+        new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+        initialized = true;
+      };
+      const isDataShort = (data) => {
+        if (typeof data === "string") {
+          return data.length < MAX_HEAP / 4;
+        }
+        return data.byteLength < MAX_HEAP;
+      };
+      let canSimplify = isDataShort;
+      switch (binary.name) {
+        case "argon2":
+        case "scrypt":
+          canSimplify = () => true;
+          break;
+        case "blake2b":
+        case "blake2s":
+          canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
+          break;
+        case "blake3":
+          canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+          break;
+        case "xxhash64":
+        // cannot simplify
+        case "xxhash3":
+        case "xxhash128":
+        case "crc64":
+          canSimplify = () => false;
+          break;
+      }
+      const calculate = (data, initParam = null, digestParam = null) => {
+        if (!canSimplify(data, initParam)) {
+          init(initParam);
+          update(data);
+          return digest("hex", digestParam);
+        }
+        const buffer = getUInt8Buffer(data);
+        memoryView.set(buffer);
+        wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
+        return getDigestHex(digestChars, memoryView, hashLength);
+      };
+      yield setupInterface();
+      return {
+        getMemory,
+        writeMemory,
+        getExports,
+        setMemorySize,
+        init,
+        update,
+        digest,
+        save,
+        load,
+        calculate,
+        hashLength
+      };
+    });
+  }
+  function lockedCreate(mutex2, binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield mutex2.lock();
+      const wasm = yield WASMInterface(binary, hashLength);
+      unlock();
+      return wasm;
+    });
+  }
+  var mutex$l = new Mutex();
+  var mutex$k = new Mutex();
+  var uint32View = new DataView(new ArrayBuffer(4));
+  var mutex$j = new Mutex();
+  var mutex$i = new Mutex();
+  var mutex$h = new Mutex();
+  var mutex$g = new Mutex();
+  var polyBuffer = new Uint8Array(8);
+  var mutex$f = new Mutex();
+  var mutex$e = new Mutex();
+  var mutex$d = new Mutex();
+  var mutex$c = new Mutex();
+  var mutex$b = new Mutex();
+  var name$a = "sha256";
+  var data$a = "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";
+  var hash$a = "8c18dd94";
+  var wasmJson$a = {
+    name: name$a,
+    data: data$a,
+    hash: hash$a
+  };
+  var mutex$a = new Mutex();
+  var mutex$9 = new Mutex();
+  var wasmCache$9 = null;
+  function sha256(data) {
+    if (wasmCache$9 === null) {
+      return lockedCreate(mutex$9, wasmJson$a, 32).then((wasm) => {
+        wasmCache$9 = wasm;
+        return wasmCache$9.calculate(data, 256);
+      });
+    }
+    try {
+      const hash = wasmCache$9.calculate(data, 256);
+      return Promise.resolve(hash);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  var mutex$8 = new Mutex();
+  var mutex$7 = new Mutex();
+  var mutex$6 = new Mutex();
+  var mutex$5 = new Mutex();
+  var seedBuffer$2 = new Uint8Array(8);
+  var mutex$4 = new Mutex();
+  var seedBuffer$1 = new Uint8Array(8);
+  var mutex$3 = new Mutex();
+  var seedBuffer = new Uint8Array(8);
+  var mutex$2 = new Mutex();
+  var mutex$1 = new Mutex();
+  var mutex = new Mutex();
+
+  // src/worker/wasmHash.ts
+  expose({ hash: async (data) => asHash(await sha256(data), true) });
+})();
+/*! Bundled license information:
+
+hash-wasm/dist/index.esm.js:
+  (*!
+   * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+   * (c) Dani Biro
+   * @license MIT
+   *)
+*/