@arkade-os/sdk 0.4.53 → 0.4.55

package/dist/{chunk-LHYNNDY6.js → chunk-ENWR2F2P.js}

@@ -1,1328 +1,9 @@
-import { VtxoScript, getSequence, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, convertVtxo } from './chunk-EFNLTS6Q.js';
+import { DEFAULT_ARKADE_SERVER_URL, eventSourceIterator, convertVtxo, isFetchTimeoutError, isEventSourceError, rateGate, baseFetch, toProviderUnavailable, ProviderUnavailableError, throwIfHttpUnavailable } from './chunk-JCJ5WFS3.js';
 import { __export } from './chunk-NSBPE2FW.js';
-import { OP, Script, SigHash, RawWitness, Transaction as Transaction$1, ScriptNum } from '@scure/btc-signer';
-import { schnorr } from '@noble/curves/secp256k1.js';
 import { hex } from '@scure/base';
+import { schnorr } from '@noble/curves/secp256k1.js';
 import { compareBytes } from '@scure/btc-signer/utils.js';
 
-var Transaction = class extends Transaction$1 {
-  static ARK_TX_OPTS = {
-    allowUnknown: true,
-    allowUnknownOutputs: true,
-    allowUnknownInputs: true
-  };
-  constructor(opts) {
-    super(withArkOpts(opts));
-  }
-  static fromPSBT(psbt_, opts) {
-    return Transaction$1.fromPSBT(psbt_, withArkOpts(opts));
-  }
-  static fromRaw(raw, opts) {
-    return Transaction$1.fromRaw(raw, withArkOpts(opts));
-  }
-};
-function withArkOpts(opts) {
-  return { ...Transaction.ARK_TX_OPTS, ...opts };
-}
-var ArkPsbtFieldKey = /* @__PURE__ */ ((ArkPsbtFieldKey2) => {
-  ArkPsbtFieldKey2["VtxoTaprootTree"] = "taptree";
-  ArkPsbtFieldKey2["VtxoTreeExpiry"] = "expiry";
-  ArkPsbtFieldKey2["Cosigner"] = "cosigner";
-  ArkPsbtFieldKey2["ConditionWitness"] = "condition";
-  ArkPsbtFieldKey2["PrevArkTx"] = "prevarktx";
-  ArkPsbtFieldKey2["PrevoutTx"] = "prevouttx";
-  return ArkPsbtFieldKey2;
-})(ArkPsbtFieldKey || {});
-var ArkPsbtFieldKeyType = 222;
-function setArkPsbtField(tx, inputIndex, coder, value) {
-  tx.updateInput(inputIndex, {
-    unknown: [...tx.getInput(inputIndex)?.unknown ?? [], coder.encode(value)]
-  });
-}
-function getArkPsbtFields(tx, inputIndex, coder) {
-  const unknown = tx.getInput(inputIndex)?.unknown ?? [];
-  const fields = [];
-  for (const u of unknown) {
-    const v = coder.decode(u);
-    if (v !== null) fields.push(v);
-  }
-  return fields;
-}
-var VtxoTaprootTree = {
-  key: "taptree" /* VtxoTaprootTree */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["taptree" /* VtxoTaprootTree */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "taptree" /* VtxoTaprootTree */)) return null;
-    return value[1];
-  })
-};
-var ConditionWitness = {
-  key: "condition" /* ConditionWitness */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["condition" /* ConditionWitness */]
-    },
-    RawWitness.encode(value)
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "condition" /* ConditionWitness */)) return null;
-    return RawWitness.decode(value[1]);
-  })
-};
-var PrevArkTxField = {
-  key: "prevarktx" /* PrevArkTx */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["prevarktx" /* PrevArkTx */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "prevarktx" /* PrevArkTx */)) return null;
-    return value[1];
-  })
-};
-var PrevoutTxField = {
-  key: "prevouttx" /* PrevoutTx */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["prevouttx" /* PrevoutTx */]
-    },
-    value
-  ],
-  decode: (value) => nullIfCatch(() => {
-    if (!checkKeyMatch(value[0], "prevouttx" /* PrevoutTx */)) return null;
-    return value[1];
-  })
-};
-var CosignerPublicKey = {
-  key: "cosigner" /* Cosigner */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: new Uint8Array([...encodedPsbtFieldKey["cosigner" /* Cosigner */], value.index])
-    },
-    value.key
-  ],
-  decode: (unknown) => nullIfCatch(() => {
-    if (!checkKeyMatch(unknown[0], "cosigner" /* Cosigner */, true)) return null;
-    return {
-      index: unknown[0].key[unknown[0].key.length - 1],
-      key: unknown[1]
-    };
-  })
-};
-var VtxoTreeExpiry = {
-  key: "expiry" /* VtxoTreeExpiry */,
-  encode: (value) => [
-    {
-      type: ArkPsbtFieldKeyType,
-      key: encodedPsbtFieldKey["expiry" /* VtxoTreeExpiry */]
-    },
-    ScriptNum(6, true).encode(value.value === 0n ? 0n : value.value)
-  ],
-  decode: (unknown) => nullIfCatch(() => {
-    if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
-    const v = ScriptNum(6, true).decode(unknown[1]);
-    if (!v) return null;
-    return sequenceToTimelock(Number(v));
-  })
-};
-var encodedPsbtFieldKey = Object.fromEntries(
-  Object.values(ArkPsbtFieldKey).map((key) => [key, new TextEncoder().encode(key)])
-);
-var nullIfCatch = (fn) => {
-  try {
-    return fn();
-  } catch {
-    return null;
-  }
-};
-function checkKeyMatch(key, arkPsbtFieldKey, prefixOnly = false) {
-  if (key.type !== ArkPsbtFieldKeyType) return false;
-  const expected = encodedPsbtFieldKey[arkPsbtFieldKey];
-  if (key.key.length < expected.length) return false;
-  if (!prefixOnly && key.key.length !== expected.length) return false;
-  for (let i = 0; i < expected.length; i++) {
-    if (key.key[i] !== expected[i]) return false;
-  }
-  return true;
-}
-
-// package.json
-var version = "0.4.53";
-
-// src/utils/fetch.ts
-var buildVersion = "0.9.9";
-var sdkVersion = `ts-sdk/${version}`;
-var FetchError = class extends Error {
-  /** The request URL that failed, when derivable from the `fetch` input. */
-  url;
-  /** The HTTP method of the failed request (defaults to `"GET"`). */
-  method;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "FetchError";
-    this.url = options.url;
-    this.method = options.method;
-  }
-};
-function baseFetch(input, init) {
-  if (typeof globalThis.fetch !== "function") {
-    throw new Error("Fetch API is not available in this environment.");
-  }
-  return globalThis.fetch(input, init).catch((cause) => {
-    const { url, method } = describeRequest(input, init);
-    throw new FetchError(`Network request failed: ${method} ${url}`, { url, method, cause });
-  });
-}
-function fetch(input, init) {
-  const headers = new Headers(init?.headers);
-  headers.set("X-Build-Version", buildVersion);
-  headers.set("X-SDK-VERSION", sdkVersion);
-  return baseFetch(input, { ...init, headers });
-}
-function describeRequest(input, init) {
-  let url;
-  if (typeof input === "string") {
-    url = input;
-  } else if (input instanceof URL) {
-    url = input.href;
-  } else {
-    url = input.url;
-  }
-  let method;
-  if (init?.method !== void 0) {
-    method = init.method;
-  } else if (input instanceof Request) {
-    method = input.method;
-  } else {
-    method = "GET";
-  }
-  return { url, method };
-}
-
-// src/providers/errors.ts
-var ArkError = class extends Error {
-  constructor(code, message, name, metadata) {
-    super(message);
-    this.code = code;
-    this.message = message;
-    this.name = name;
-    this.metadata = metadata;
-  }
-  code;
-  message;
-  name;
-  metadata;
-};
-var ArkErrorName = {
-  DIGEST_MISMATCH: "DIGEST_MISMATCH",
-  VTXO_ALREADY_SPENT: "VTXO_ALREADY_SPENT",
-  INVALID_TX_FILTER: "INVALID_TX_FILTER",
-  TX_FILTERS_LIMIT_EXCEEDED: "TX_FILTERS_LIMIT_EXCEEDED",
-  /**
-   * A CLTV closure was spent before its absolute locktime matured. Raised only by
-   * `submitTx` (never `finalizeTx`), with metadata
-   * `{ locktime, current_locktime, type: "height" | "time" }`.
-   *
-   * Self-healing, so defer and retry rather than fail: the server matures a
-   * seconds-locktime against the **chain tip block's timestamp**, not its wall clock,
-   * so a spend attempted promptly at maturity is rejected until a later block lands.
-   */
-  FORFEIT_CLOSURE_LOCKED: "FORFEIT_CLOSURE_LOCKED"
-};
-function isArkError(error, name) {
-  return error instanceof ArkError && (name === void 0 || error.name === name);
-}
-var ProviderUnavailableError = class extends Error {
-  /** Always `true`: this error type only ever wraps retryable conditions. */
-  retryable = true;
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "ProviderUnavailableError";
-  }
-};
-function throwIfHttpUnavailable(response, kind, body) {
-  if (body !== void 0 && maybeArkError(new Error(body))) return;
-  if (response.status === 429 || response.status >= 500) {
-    throw new ProviderUnavailableError(
-      `${kind} unavailable: ${response.status} ${response.statusText}`
-    );
-  }
-}
-function toProviderUnavailable(err, kind) {
-  if (err instanceof FetchError) {
-    return new ProviderUnavailableError(`${kind} request failed`, { cause: err });
-  }
-  return err;
-}
-function maybeArkError(error) {
-  try {
-    if (!(error instanceof Error)) return void 0;
-    const decoded = JSON.parse(error.message);
-    if (Array.isArray(decoded.details)) {
-      for (const details of decoded.details) {
-        if (!("@type" in details)) continue;
-        const type = details["@type"];
-        if (type !== "type.googleapis.com/ark.v1.ErrorDetails") continue;
-        if (!("code" in details)) continue;
-        const code = details.code;
-        if (!("message" in details)) continue;
-        const message = details.message;
-        if (!("name" in details)) continue;
-        const name = details.name;
-        let metadata;
-        if ("metadata" in details && isMetadata(details.metadata)) {
-          metadata = details.metadata;
-        }
-        return new ArkError(code, message, name, metadata);
-      }
-    }
-    if (typeof decoded.message === "string") {
-      const m = decoded.message.match(/^([A-Z][A-Z0-9_]*) \((\d+)\): ([\s\S]*)$/);
-      if (m) return new ArkError(Number(m[2]), m[3], m[1]);
-    }
-    return void 0;
-  } catch (e) {
-    return void 0;
-  }
-}
-function isMetadata(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var Intent;
-((Intent2) => {
-  function create(message, ins, outputs = []) {
-    if (typeof message !== "string") {
-      message = encodeMessage(message);
-    }
-    if (ins.length == 0) throw new Error("intent proof requires at least one input");
-    const inputs = ins.map(prepareCoinAsIntentProofInput);
-    if (!validateInputs(inputs)) ;
-    if (!validateOutputs(outputs)) ;
-    const toSpend = craftToSpendTx(message, inputs[0].witnessUtxo.script);
-    return craftToSignTx(toSpend, inputs, outputs, message);
-  }
-  Intent2.create = create;
-  function fee(proof) {
-    let sumOfInputs = 0n;
-    for (let i = 0; i < proof.inputsLength; i++) {
-      const input = proof.getInput(i);
-      if (input.witnessUtxo === void 0)
-        throw new Error("intent proof input requires witness utxo");
-      sumOfInputs += input.witnessUtxo.amount;
-    }
-    let sumOfOutputs = 0n;
-    for (let i = 0; i < proof.outputsLength; i++) {
-      const output = proof.getOutput(i);
-      if (output.amount === void 0) throw new Error("intent proof output requires amount");
-      sumOfOutputs += output.amount;
-    }
-    if (sumOfOutputs > sumOfInputs) {
-      throw new Error(
-        `intent proof output amount is greater than input amount: ${sumOfOutputs} > ${sumOfInputs}`
-      );
-    }
-    return Number(sumOfInputs - sumOfOutputs);
-  }
-  Intent2.fee = fee;
-  function encodeMessage(message) {
-    switch (message.type) {
-      case "register":
-        return JSON.stringify({
-          type: "register",
-          onchain_output_indexes: message.onchain_output_indexes,
-          valid_at: message.valid_at,
-          expire_at: message.expire_at,
-          cosigners_public_keys: message.cosigners_public_keys
-        });
-      case "delete":
-        return JSON.stringify({
-          type: "delete",
-          expire_at: message.expire_at
-        });
-      case "get-pending-tx":
-        return JSON.stringify({
-          type: "get-pending-tx",
-          expire_at: message.expire_at
-        });
-    }
-  }
-  Intent2.encodeMessage = encodeMessage;
-})(Intent || (Intent = {}));
-var OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([OP.RETURN]);
-var ZERO_32 = new Uint8Array(32).fill(0);
-var MAX_INDEX = 4294967295;
-var TAG_INTENT_PROOF = "ark-intent-proof-message";
-var PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE = 9;
-function validateInput(input) {
-  if (input.index === void 0) throw new Error("intent proof input requires index");
-  if (input.txid === void 0) throw new Error("intent proof input requires txid");
-  if (input.witnessUtxo === void 0)
-    throw new Error("intent proof input requires witness utxo");
-  return true;
-}
-function validateInputs(inputs) {
-  inputs.forEach(validateInput);
-  return true;
-}
-function validateOutput(output) {
-  if (output.amount === void 0) throw new Error("intent proof output requires amount");
-  if (output.script === void 0) throw new Error("intent proof output requires script");
-  return true;
-}
-function validateOutputs(outputs) {
-  outputs.forEach(validateOutput);
-  return true;
-}
-function craftToSpendTx(message, pkScript, tag = TAG_INTENT_PROOF) {
-  const messageHash = hashMessage(message, tag);
-  const tx = new Transaction({
-    version: 0
-  });
-  tx.addInput({
-    txid: ZERO_32,
-    // zero hash
-    index: MAX_INDEX,
-    sequence: 0
-  });
-  tx.addOutput({
-    amount: 0n,
-    script: pkScript
-  });
-  tx.updateInput(0, {
-    finalScriptSig: Script.encode(["OP_0", messageHash])
-  });
-  return tx;
-}
-function craftToSignTx(toSpend, inputs, outputs, message) {
-  const firstInput = inputs[0];
-  const tx = new Transaction({
-    version: 2,
-    lockTime: 0
-  });
-  tx.addInput({
-    ...firstInput,
-    txid: toSpend.id,
-    index: 0,
-    witnessUtxo: {
-      script: firstInput.witnessUtxo.script,
-      amount: 0n
-    },
-    sighashType: SigHash.ALL
-  });
-  for (const [i, input] of inputs.entries()) {
-    tx.addInput({
-      ...input,
-      sighashType: SigHash.ALL
-    });
-    if (input.unknown?.length) {
-      tx.updateInput(i + 1, {
-        unknown: input.unknown
-      });
-    }
-  }
-  if (outputs.length === 0) {
-    outputs = [
-      {
-        amount: 0n,
-        script: OP_RETURN_EMPTY_PKSCRIPT
-      }
-    ];
-  }
-  for (const output of outputs) {
-    tx.addOutput({
-      amount: output.amount,
-      script: output.script
-    });
-  }
-  const global = tx.global;
-  global.unknown = [
-    ...global.unknown ?? [],
-    [
-      { type: PSBT_GLOBAL_GENERIC_SIGNED_MESSAGE, key: new Uint8Array() },
-      new TextEncoder().encode(message)
-    ]
-  ];
-  return tx;
-}
-function hashMessage(message, tag = TAG_INTENT_PROOF) {
-  return schnorr.utils.taggedHash(tag, new TextEncoder().encode(message));
-}
-function prepareCoinAsIntentProofInput(coin) {
-  if (!("tapTree" in coin)) {
-    return coin;
-  }
-  const vtxoScript = VtxoScript.decode(coin.tapTree);
-  const sequence = getSequence(coin.intentTapLeafScript);
-  const unknown = [VtxoTaprootTree.encode(coin.tapTree)];
-  if (coin.extraWitness) {
-    unknown.push(ConditionWitness.encode(coin.extraWitness));
-  }
-  return {
-    txid: hex.decode(coin.txid),
-    index: coin.vout,
-    witnessUtxo: {
-      amount: BigInt(coin.value),
-      script: vtxoScript.pkScript
-    },
-    sequence,
-    tapLeafScript: [coin.intentTapLeafScript],
-    unknown
-  };
-}
-
-// src/providers/utils.ts
-function createAbortError() {
-  const error = new Error("EventSource closed");
-  error.name = "AbortError";
-  return error;
-}
-function eventSourceIterator(eventSource) {
-  const messageQueue = [];
-  const errorQueue = [];
-  let messageResolve = null;
-  let errorResolve = null;
-  let closed = false;
-  let cleanedUp = false;
-  const cleanup = () => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    eventSource.removeEventListener("message", messageHandler);
-    eventSource.removeEventListener("error", errorHandler);
-  };
-  const close = () => {
-    if (closed) return;
-    closed = true;
-    messageQueue.length = 0;
-    errorQueue.length = 0;
-    eventSource.close();
-    cleanup();
-    if (errorResolve) {
-      const reject = errorResolve;
-      messageResolve = null;
-      errorResolve = null;
-      reject(createAbortError());
-    }
-  };
-  const messageHandler = (event) => {
-    if (closed) return;
-    if (messageResolve) {
-      const resolve = messageResolve;
-      messageResolve = null;
-      errorResolve = null;
-      resolve(event);
-    } else {
-      messageQueue.push(event);
-    }
-  };
-  const errorHandler = () => {
-    if (closed) return;
-    const error = new Error("EventSource error");
-    error.name = "EventSourceError";
-    if (errorResolve) {
-      const reject = errorResolve;
-      messageResolve = null;
-      errorResolve = null;
-      reject(error);
-    } else {
-      errorQueue.push(error);
-    }
-  };
-  eventSource.addEventListener("message", messageHandler);
-  eventSource.addEventListener("error", errorHandler);
-  const gen = (async function* () {
-    try {
-      while (!closed) {
-        if (messageQueue.length > 0) {
-          yield messageQueue.shift();
-          continue;
-        }
-        if (errorQueue.length > 0) {
-          const error = errorQueue.shift();
-          throw error;
-        }
-        const result = await new Promise((resolve, reject) => {
-          messageResolve = resolve;
-          errorResolve = reject;
-        }).finally(() => {
-          messageResolve = null;
-          errorResolve = null;
-        });
-        if (!closed && result) {
-          yield result;
-        }
-      }
-    } finally {
-      closed = true;
-      cleanup();
-      eventSource.close();
-    }
-  })();
-  const origReturn = gen.return.bind(gen);
-  const managed = gen;
-  managed.close = close;
-  managed.return = (value) => {
-    close();
-    return origReturn(value);
-  };
-  return managed;
-}
-function isEventSourceError(error) {
-  return error instanceof Error && error.name === "EventSourceError";
-}
-
-// src/providers/rateGate.ts
-var DEFAULT_MAX_CONCURRENT = 6;
-var DEFAULT_COOLDOWN_MS = 5e3;
-var MAX_COOLDOWN_MS = 6e4;
-var DEFAULT_JITTER_MS = 500;
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function parseRetryAfterMs(header) {
-  if (header === null || header === void 0) return void 0;
-  const trimmed = header.trim();
-  if (trimmed === "") return void 0;
-  const seconds = Number(trimmed);
-  if (Number.isFinite(seconds)) return seconds < 0 ? void 0 : seconds * 1e3;
-  const at = Date.parse(trimmed);
-  if (!Number.isNaN(at)) return Math.max(0, at - Date.now());
-  return void 0;
-}
-function requestOrigin(input) {
-  let url;
-  if (typeof input === "string") {
-    url = input;
-  } else if (input instanceof URL) {
-    url = input.href;
-  } else {
-    url = input.url;
-  }
-  try {
-    return new URL(url).origin;
-  } catch {
-    return url;
-  }
-}
-var OriginRateGate = class {
-  states = /* @__PURE__ */ new Map();
-  maxConcurrent;
-  defaultCooldownMs;
-  maxCooldownMs;
-  jitterMs;
-  constructor(options) {
-    this.maxConcurrent = options?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
-    this.defaultCooldownMs = options?.defaultCooldownMs ?? DEFAULT_COOLDOWN_MS;
-    this.maxCooldownMs = options?.maxCooldownMs ?? MAX_COOLDOWN_MS;
-    this.jitterMs = options?.jitterMs ?? DEFAULT_JITTER_MS;
-  }
-  /**
-   * Run `fn` under the origin's concurrency cap and behind any active
-   * cooldown. Put only the request in `fn`: the slot is released as soon as
-   * it settles, so body parsing doesn't hold one.
-   */
-  async run(input, fn) {
-    const state = this.stateFor(requestOrigin(input));
-    await this.acquire(state);
-    try {
-      for (; ; ) {
-        const remaining = state.blockedUntil - Date.now();
-        if (remaining <= 0) break;
-        await sleep(remaining + Math.random() * this.jitterMs);
-      }
-      return await fn();
-    } finally {
-      this.release(state);
-    }
-  }
-  /**
-   * {@link run} for a request whose response the gate should inspect: a `429`
-   * is recorded *before* the slot is released. Reporting after `run()` resolves
-   * is too late — `release()` hands the slot to the next queued waiter, which
-   * resumes, sees no cooldown, and sends into the limiter that just refused us.
-   *
-   * Prefer this over `run` for anything returning a `Response`.
-   */
-  runHttp(input, fn) {
-    return this.run(input, async () => {
-      const response = await fn();
-      if (response.status === 429) {
-        this.reportRateLimited(input, response.headers?.get("retry-after"));
-      }
-      return response;
-    });
-  }
-  /**
-   * Record an observed `429`, pausing every gated request to that origin.
-   * Monotonic: a shorter cooldown never shortens one already in effect.
-   */
-  reportRateLimited(input, retryAfterHeader) {
-    const cooldown = Math.min(
-      parseRetryAfterMs(retryAfterHeader) ?? this.defaultCooldownMs,
-      this.maxCooldownMs
-    );
-    const state = this.stateFor(requestOrigin(input));
-    state.blockedUntil = Math.max(state.blockedUntil, Date.now() + cooldown);
-  }
-  /** Milliseconds left on `input` origin's cooldown; `0` when not cooling down. */
-  cooldownRemainingMs(input) {
-    const state = this.states.get(requestOrigin(input));
-    if (!state) return 0;
-    return Math.max(0, state.blockedUntil - Date.now());
-  }
-  /**
-   * Drop all per-origin state, so test suites don't inherit each other's
-   * cooldowns. Waiters queued on the discarded state still drain normally.
-   */
-  reset() {
-    this.states.clear();
-  }
-  stateFor(origin) {
-    let state = this.states.get(origin);
-    if (!state) {
-      state = { blockedUntil: 0, active: 0, queue: [] };
-      this.states.set(origin, state);
-    }
-    return state;
-  }
-  acquire(state) {
-    if (state.active < this.maxConcurrent) {
-      state.active += 1;
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      state.queue.push(() => {
-        state.active += 1;
-        resolve();
-      });
-    });
-  }
-  release(state) {
-    state.active -= 1;
-    const next = state.queue.shift();
-    if (next) next();
-  }
-};
-var rateGate = new OriginRateGate();
-
-// src/providers/ark.ts
-var DigestMismatchError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DigestMismatchError";
-  }
-};
-var SettlementEventType = /* @__PURE__ */ ((SettlementEventType2) => {
-  SettlementEventType2["BatchStarted"] = "batch_started";
-  SettlementEventType2["BatchFinalization"] = "batch_finalization";
-  SettlementEventType2["BatchFinalized"] = "batch_finalized";
-  SettlementEventType2["BatchFailed"] = "batch_failed";
-  SettlementEventType2["TreeSigningStarted"] = "tree_signing_started";
-  SettlementEventType2["TreeNonces"] = "tree_nonces";
-  SettlementEventType2["TreeTx"] = "tree_tx";
-  SettlementEventType2["TreeSignature"] = "tree_signature";
-  SettlementEventType2["StreamStarted"] = "stream_started";
-  return SettlementEventType2;
-})(SettlementEventType || {});
-var RestArkProvider = class {
-  constructor(serverUrl = DEFAULT_ARKADE_SERVER_URL) {
-    this.serverUrl = serverUrl;
-  }
-  serverUrl;
-  /**
-   * Last server-info digest seen (from {@link getInfo}). Sent as `X-Digest`
-   * on outgoing requests so arkd can reject a client whose cached info is
-   * stale. Empty until the first {@link getInfo}.
-   */
-  _digest = "";
-  _serverInfoListeners = /* @__PURE__ */ new Set();
-  /**
-   * Subscribe to server-info changes. Fired when a request is rejected with
-   * `DIGEST_MISMATCH` and fresh info is re-fetched, so consumers (the wallet)
-   * can re-derive signer-dependent state mid-session without polling. Returns
-   * an unsubscribe function.
-   */
-  onServerInfoChanged(listener) {
-    this._serverInfoListeners.add(listener);
-    return () => {
-      this._serverInfoListeners.delete(listener);
-    };
-  }
-  emitServerInfoChanged(info) {
-    for (const listener of this._serverInfoListeners) {
-      try {
-        listener(info);
-      } catch (e) {
-        console.warn("onServerInfoChanged listener threw", e);
-      }
-    }
-  }
-  /**
-   * `fetch` wrapper for arkd requests that participates in server-info digest
-   * negotiation. Sends the cached `X-Digest`; when arkd rejects a request with
-   * `DIGEST_MISMATCH`, refreshes {@link getInfo} (updating the digest), fires
-   * {@link onServerInfoChanged}, and THROWS {@link DigestMismatchError} — it
-   * never silently retries, since the in-flight request was built against the
-   * now-stale config. Dormant until arkd returns the error — then it is the
-   * instant, event-driven signer-rotation trigger. {@link getInfo} itself never
-   * routes through here: it is the refresh path and must not be digest-gated.
-   */
-  async authedFetch(url, init) {
-    const digest = this._digest;
-    const headers = {
-      ...init.headers
-    };
-    if (digest) headers["X-Digest"] = digest;
-    let response;
-    try {
-      response = await fetch(url, { ...init, headers });
-    } catch (err) {
-      throw toProviderUnavailable(err, "arkade");
-    }
-    if (response.ok) return response;
-    if (response.status === 429) {
-      rateGate.reportRateLimited(url, response.headers?.get("retry-after"));
-    }
-    let body;
-    try {
-      body = await response.clone().text();
-    } catch (e) {
-      console.warn("authedFetch could not read response body for digest check", e);
-      throwIfHttpUnavailable(response, "arkade");
-      return response;
-    }
-    const arkError = maybeArkError(new Error(body));
-    if (!arkError) throwIfHttpUnavailable(response, "arkade");
-    if (!isArkError(arkError, ArkErrorName.DIGEST_MISMATCH)) return response;
-    this._digest = "";
-    const info = await this.getInfo();
-    this.emitServerInfoChanged(info);
-    throw new DigestMismatchError(
-      "Arkade server reported a configuration digest mismatch; server info was refreshed. Rebuild and retry the request under the new server info."
-    );
-  }
-  async getInfo() {
-    const url = `${this.serverUrl}/v1/info`;
-    const response = await rateGate.runHttp(url, () => fetch(url));
-    if (!response.ok) {
-      const errorText = await response.text();
-      throwIfHttpUnavailable(response, "arkade", errorText);
-      handleError(errorText, `Failed to get server info: ${response.statusText}`);
-    }
-    const fromServer = await response.json();
-    const info = {
-      boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
-      checkpointTapscript: fromServer.checkpointTapscript ?? "",
-      deprecatedSigners: fromServer.deprecatedSigners?.map((signer) => ({
-        // arkd advertises `cutoffDate` as a non-nullable field, so it
-        // is always a bigint here — `0n` is the sentinel for "no
-        // cutoff" (the classifier maps it to DUE_NOW). The grpc-gateway
-        // marshals with EmitUnpopulated, so an unset `cutoff_date`
-        // already arrives as `"0"`; a genuinely missing field defaults
-        // to `0n` too. Never collapse to `undefined`.
-        cutoffDate: BigInt(signer.cutoffDate ?? 0),
-        pubkey: signer.pubkey ?? ""
-      })) ?? [],
-      digest: fromServer.digest ?? "",
-      dust: BigInt(fromServer.dust ?? 0),
-      fees: {
-        intentFee: fromServer.fees?.intentFee ?? {},
-        txFeeRate: fromServer?.fees?.txFeeRate ?? ""
-      },
-      forfeitAddress: fromServer.forfeitAddress ?? "",
-      forfeitPubkey: fromServer.forfeitPubkey ?? "",
-      network: fromServer.network ?? "",
-      scheduledSession: "scheduledSession" in fromServer && fromServer.scheduledSession != null ? {
-        duration: BigInt(fromServer.scheduledSession.duration ?? 0),
-        nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
-        nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
-        period: BigInt(fromServer.scheduledSession.period ?? 0),
-        fees: fromServer.scheduledSession.fees ?? {}
-      } : void 0,
-      serviceStatus: fromServer.serviceStatus ?? {},
-      sessionDuration: BigInt(fromServer.sessionDuration ?? 0),
-      signerPubkey: fromServer.signerPubkey ?? "",
-      unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
-      utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
-      utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
-      version: fromServer.version ?? "",
-      vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
-      vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0)
-    };
-    this._digest = info.digest;
-    return info;
-  }
-  async submitTx(signedArkTx, checkpointTxs) {
-    const url = `${this.serverUrl}/v1/tx/submit`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        signedArkTx,
-        checkpointTxs
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit virtual transaction: ${errorText}`);
-    }
-    const data = await response.json();
-    return {
-      arkTxid: data.arkTxid,
-      finalArkTx: data.finalArkTx,
-      signedCheckpointTxs: data.signedCheckpointTxs
-    };
-  }
-  async finalizeTx(arkTxid, finalCheckpointTxs) {
-    const url = `${this.serverUrl}/v1/tx/finalize`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        arkTxid,
-        finalCheckpointTxs
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to finalize offchain transaction: ${errorText}`);
-    }
-  }
-  async registerIntent(intent) {
-    const url = `${this.serverUrl}/v1/batch/registerIntent`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        intent: {
-          proof: intent.proof,
-          message: Intent.encodeMessage(intent.message)
-        }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to register intent: ${errorText}`);
-    }
-    const data = await response.json();
-    return data.intentId;
-  }
-  async deleteIntent(intent) {
-    const url = `${this.serverUrl}/v1/batch/deleteIntent`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        intent: {
-          proof: intent.proof,
-          message: Intent.encodeMessage(intent.message)
-        }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to delete intent: ${errorText}`);
-    }
-  }
-  async confirmRegistration(intentId) {
-    const url = `${this.serverUrl}/v1/batch/ack`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        intentId
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to confirm registration: ${errorText}`);
-    }
-  }
-  async submitTreeNonces(batchId, pubkey, nonces) {
-    const url = `${this.serverUrl}/v1/batch/tree/submitNonces`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        batchId,
-        pubkey,
-        treeNonces: encodeMusig2Nonces(nonces)
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit tree nonces: ${errorText}`);
-    }
-  }
-  async submitTreeSignatures(batchId, pubkey, signatures) {
-    const url = `${this.serverUrl}/v1/batch/tree/submitSignatures`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        batchId,
-        pubkey,
-        treeSignatures: encodeMusig2Signatures(signatures)
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit tree signatures: ${errorText}`);
-    }
-  }
-  async submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
-    const url = `${this.serverUrl}/v1/batch/submitForfeitTxs`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        signedForfeitTxs,
-        signedCommitmentTx
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
-    }
-  }
-  getEventStream(signal, topics) {
-    const url = `${this.serverUrl}/v1/batch/events`;
-    const queryParams = topics.length > 0 ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}` : "";
-    let iterator = null;
-    const closeIterator = () => iterator?.close();
-    const self = this;
-    const gen = (async function* () {
-      const abortHandler = closeIterator;
-      signal?.addEventListener("abort", abortHandler);
-      try {
-        while (!signal?.aborted) {
-          const currentIterator = eventSourceIterator(new EventSource(url + queryParams));
-          iterator = currentIterator;
-          try {
-            for await (const event of currentIterator) {
-              if (signal?.aborted) break;
-              try {
-                const data = JSON.parse(event.data);
-                const settlementEvent = self.parseSettlementEvent(data);
-                if (settlementEvent) {
-                  yield settlementEvent;
-                }
-              } catch (err) {
-                console.error("Failed to parse event:", err);
-                throw err;
-              }
-            }
-          } catch (error) {
-            if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
-              break;
-            }
-            if (isFetchTimeoutError(error)) {
-              console.debug("Timeout error ignored");
-              continue;
-            }
-            if (isEventSourceError(error)) {
-              throw error;
-            }
-            console.error("Event stream error:", error);
-            throw error;
-          } finally {
-            currentIterator.close();
-            iterator = null;
-          }
-        }
-      } finally {
-        signal?.removeEventListener("abort", abortHandler);
-        closeIterator();
-      }
-    })();
-    const origReturn = gen.return.bind(gen);
-    gen.return = (value) => {
-      closeIterator();
-      return origReturn(value);
-    };
-    return gen;
-  }
-  getTransactionsStream(signal) {
-    const url = `${this.serverUrl}/v1/txs`;
-    let iterator = null;
-    const closeIterator = () => iterator?.close();
-    const self = this;
-    const gen = (async function* () {
-      const abortHandler = closeIterator;
-      signal?.addEventListener("abort", abortHandler);
-      try {
-        while (!signal?.aborted) {
-          try {
-            const currentIterator = eventSourceIterator(new EventSource(url));
-            iterator = currentIterator;
-            for await (const event of currentIterator) {
-              if (signal?.aborted) break;
-              try {
-                const data = JSON.parse(event.data);
-                const txNotification = self.parseTransactionNotification(data);
-                if (txNotification) {
-                  yield txNotification;
-                }
-              } catch (err) {
-                console.error("Failed to parse transaction notification:", err);
-                throw err;
-              }
-            }
-          } catch (error) {
-            if (signal?.aborted || error instanceof Error && error.name === "AbortError") {
-              break;
-            }
-            if (isFetchTimeoutError(error)) {
-              console.debug("Timeout error ignored");
-              continue;
-            }
-            if (isEventSourceError(error)) {
-              throw error;
-            }
-            console.error("Transaction stream error:", error);
-            throw error;
-          } finally {
-            closeIterator();
-            iterator = null;
-          }
-        }
-      } finally {
-        signal?.removeEventListener("abort", abortHandler);
-        closeIterator();
-      }
-    })();
-    const origReturn = gen.return.bind(gen);
-    gen.return = (value) => {
-      closeIterator();
-      return origReturn(value);
-    };
-    return gen;
-  }
-  async getPendingTxs(intent) {
-    const url = `${this.serverUrl}/v1/tx/pending`;
-    const response = await this.authedFetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        intent: {
-          proof: intent.proof,
-          message: Intent.encodeMessage(intent.message)
-        }
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      handleError(errorText, `Failed to get pending transactions: ${errorText}`);
-    }
-    const data = await response.json();
-    return data.pendingTxs;
-  }
-  parseSettlementEvent(data) {
-    if (data.batchStarted) {
-      return {
-        type: "batch_started" /* BatchStarted */,
-        id: data.batchStarted.id,
-        intentIdHashes: data.batchStarted.intentIdHashes,
-        batchExpiry: BigInt(data.batchStarted.batchExpiry)
-      };
-    }
-    if (data.batchFinalization) {
-      return {
-        type: "batch_finalization" /* BatchFinalization */,
-        id: data.batchFinalization.id,
-        commitmentTx: data.batchFinalization.commitmentTx
-      };
-    }
-    if (data.batchFinalized) {
-      return {
-        type: "batch_finalized" /* BatchFinalized */,
-        id: data.batchFinalized.id,
-        commitmentTxid: data.batchFinalized.commitmentTxid
-      };
-    }
-    if (data.batchFailed) {
-      return {
-        type: "batch_failed" /* BatchFailed */,
-        id: data.batchFailed.id,
-        reason: data.batchFailed.reason
-      };
-    }
-    if (data.treeSigningStarted) {
-      return {
-        type: "tree_signing_started" /* TreeSigningStarted */,
-        id: data.treeSigningStarted.id,
-        cosignersPublicKeys: data.treeSigningStarted.cosignersPubkeys,
-        unsignedCommitmentTx: data.treeSigningStarted.unsignedCommitmentTx
-      };
-    }
-    if (data.treeNoncesAggregated) {
-      return null;
-    }
-    if (data.treeNonces) {
-      return {
-        type: "tree_nonces" /* TreeNonces */,
-        id: data.treeNonces.id,
-        topic: data.treeNonces.topic,
-        txid: data.treeNonces.txid,
-        nonces: decodeMusig2Nonces(data.treeNonces.nonces)
-        // pubkey -> public nonce
-      };
-    }
-    if (data.treeTx) {
-      const children = Object.fromEntries(
-        Object.entries(data.treeTx.children).map(([outputIndex, txid]) => {
-          return [parseInt(outputIndex), txid];
-        })
-      );
-      return {
-        type: "tree_tx" /* TreeTx */,
-        id: data.treeTx.id,
-        topic: data.treeTx.topic,
-        batchIndex: data.treeTx.batchIndex,
-        chunk: {
-          txid: data.treeTx.txid,
-          tx: data.treeTx.tx,
-          children
-        }
-      };
-    }
-    if (data.treeSignature) {
-      return {
-        type: "tree_signature" /* TreeSignature */,
-        id: data.treeSignature.id,
-        topic: data.treeSignature.topic,
-        batchIndex: data.treeSignature.batchIndex,
-        txid: data.treeSignature.txid,
-        signature: data.treeSignature.signature
-      };
-    }
-    if (data.streamStarted) {
-      return {
-        type: "stream_started" /* StreamStarted */,
-        id: data.streamStarted.id
-      };
-    }
-    if (data.heartbeat) {
-      return null;
-    }
-    console.warn("Unknown event type:", data);
-    return null;
-  }
-  parseTransactionNotification(data) {
-    if (data.commitmentTx) {
-      return {
-        commitmentTx: {
-          txid: data.commitmentTx.txid,
-          tx: data.commitmentTx.tx,
-          spentVtxos: data.commitmentTx.spentVtxos.map(mapVtxo),
-          spendableVtxos: data.commitmentTx.spendableVtxos.map(mapVtxo),
-          checkpointTxs: data.commitmentTx.checkpointTxs
-        }
-      };
-    }
-    if (data.arkTx) {
-      return {
-        arkTx: {
-          txid: data.arkTx.txid,
-          tx: data.arkTx.tx,
-          spentVtxos: data.arkTx.spentVtxos.map(mapVtxo),
-          spendableVtxos: data.arkTx.spendableVtxos.map(mapVtxo),
-          checkpointTxs: data.arkTx.checkpointTxs
-        }
-      };
-    }
-    if (data.heartbeat) {
-      return null;
-    }
-    console.warn("Unknown transaction notification type:", data);
-    return null;
-  }
-};
-function encodeMusig2Nonces(nonces) {
-  const noncesObject = {};
-  for (const [txid, nonce] of nonces) {
-    noncesObject[txid] = hex.encode(nonce.pubNonce);
-  }
-  return noncesObject;
-}
-function encodeMusig2Signatures(signatures) {
-  const sigObject = {};
-  for (const [txid, sig] of signatures) {
-    sigObject[txid] = hex.encode(sig.encode());
-  }
-  return sigObject;
-}
-function decodeMusig2Nonces(noncesObject) {
-  return new Map(
-    Object.entries(noncesObject).map(([txid, nonce]) => {
-      if (typeof nonce !== "string") {
-        throw new Error("invalid nonce");
-      }
-      return [txid, { pubNonce: hex.decode(nonce) }];
-    })
-  );
-}
-function isFetchTimeoutError(err) {
-  const checkError = (error) => {
-    if (!(error instanceof Error)) return false;
-    const isCloudflare524 = error.name === "TypeError" && error.message === "Failed to fetch";
-    return isCloudflare524 || error.name === "HeadersTimeoutError" || error.name === "BodyTimeoutError" || error.code === "UND_ERR_HEADERS_TIMEOUT" || error.code === "UND_ERR_BODY_TIMEOUT";
-  };
-  return checkError(err) || checkError(err.cause);
-}
-function mapVtxo(vtxo) {
-  return {
-    outpoint: {
-      txid: vtxo.outpoint.txid,
-      vout: vtxo.outpoint.vout
-    },
-    amount: vtxo.amount,
-    script: vtxo.script,
-    createdAt: vtxo.createdAt,
-    expiresAt: vtxo.expiresAt,
-    commitmentTxids: vtxo.commitmentTxids,
-    isPreconfirmed: vtxo.isPreconfirmed,
-    isSwept: vtxo.isSwept,
-    isUnrolled: vtxo.isUnrolled,
-    isSpent: vtxo.isSpent,
-    spentBy: vtxo.spentBy,
-    settledBy: vtxo.settledBy,
-    arkTxid: vtxo.arkTxid
-  };
-}
-function handleError(errorText, defaultMessage) {
-  const error = new Error(errorText);
-  const arkError = maybeArkError(error);
-  throw arkError ?? new Error(defaultMessage);
-}
-
 // src/extension/asset/index.ts
 var asset_exports = {};
 __export(asset_exports, {
@@ -2603,7 +1284,7 @@ async function indexerFetch(input, init) {
     } catch (err) {
       const mapped = toProviderUnavailable(err, "indexer");
       if (lastAttempt || !(mapped instanceof ProviderUnavailableError)) throw mapped;
-      await sleep2(retryDelayMs(attempt));
+      await sleep(retryDelayMs(attempt));
       continue;
     }
     if (res.ok) return res;
@@ -2617,7 +1298,7 @@ async function indexerFetch(input, init) {
       throwIfHttpUnavailable(res, "indexer", body);
     } catch (err) {
       if (lastAttempt) throw err;
-      await sleep2(retryDelayMs(attempt));
+      await sleep(retryDelayMs(attempt));
       continue;
     }
     return res;
@@ -2626,7 +1307,7 @@ async function indexerFetch(input, init) {
 function retryDelayMs(attempt) {
   return INDEXER_RETRY_BASE_MS * 2 ** (attempt - 1);
 }
-var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var IndexerTxType = /* @__PURE__ */ ((IndexerTxType2) => {
   IndexerTxType2[IndexerTxType2["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";
   IndexerTxType2[IndexerTxType2["INDEXER_TX_TYPE_RECEIVED"] = 1] = "INDEXER_TX_TYPE_RECEIVED";
@@ -3101,6 +1782,6 @@ var Response;
   Response2.isGetAssetResponse = isGetAssetResponse;
 })(Response || (Response = {}));
 
-export { ArkError, ArkErrorName, ArkPsbtFieldKey, ArkPsbtFieldKeyType, AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, BufferReader, BufferWriter, ChainTxType, ConditionWitness, CosignerPublicKey, DigestMismatchError, FetchError, IndexerTxType, Intent, Metadata, OP_RETURN_EMPTY_PKSCRIPT, Packet, PrevArkTxField, PrevoutTxField, ProviderUnavailableError, RestArkProvider, RestIndexerProvider, SettlementEventType, Transaction, VtxoTaprootTree, VtxoTreeExpiry, asset_exports, baseFetch, buildVersion, craftToSpendTx, fetch, getArkPsbtFields, isArkError, isEventSourceError, isFetchTimeoutError, maybeArkError, rateGate, sdkVersion, setArkPsbtField };
-//# sourceMappingURL=chunk-LHYNNDY6.js.map
-//# sourceMappingURL=chunk-LHYNNDY6.js.map
+export { AssetGroup, AssetId, AssetInput, AssetOutput, AssetRef, BufferReader, BufferWriter, ChainTxType, IndexerTxType, Metadata, Packet, RestIndexerProvider, asset_exports };
+//# sourceMappingURL=chunk-ENWR2F2P.js.map
+//# sourceMappingURL=chunk-ENWR2F2P.js.map