facturas 0.20.4 → 0.21.0

package/dist/{chunk-CYXS3F34.mjs → chunk-WEEV76IC.mjs}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-C2KX652X.mjs";
 import {
   createPadronService
-} from "./chunk-UOIZQMA6.mjs";
+} from "./chunk-QHNI4ZIA.mjs";
 import {
   arcaMinorUnitsToNumber,
   assertArcaMinorUnits,
@@ -22,22 +22,23 @@ import {
   roundHalfEvenRatio,
   serializeArcaExchangeRate,
   toIsoDate
-} from "./chunk-6U4NRHFP.mjs";
+} from "./chunk-FQD2PZXE.mjs";
 import {
   createWsmtxcaService
-} from "./chunk-WG6TAMBB.mjs";
+} from "./chunk-HSGTCGUX.mjs";
 import {
   ArcaConfigurationError,
   ArcaError,
   ArcaInputError,
   ArcaInvalidSoapResponseError,
+  ArcaLockTimeoutError,
   ArcaServiceError,
   ArcaSoapFaultError,
   ArcaTransportError,
   createResponseBodyDiagnostic,
   createSafeErrorDiagnostic,
   toArcaSafeErrorMetadata
-} from "./chunk-NT2A6YMO.mjs";
+} from "./chunk-Q7IURW54.mjs";
 
 // src/config.ts
 var ARCA_ENVIRONMENTS = ["production", "test"];
@@ -2701,7 +2702,7 @@ async function withWsaaSessionStoreLock(config, key, service, fn) {
     if (entered) {
       throw error;
     }
-    if (error instanceof ArcaConfigurationError) {
+    if (error instanceof ArcaConfigurationError || error instanceof ArcaLockTimeoutError) {
       throw error;
     }
     throw new ArcaConfigurationError(
@@ -3876,48 +3877,39 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
     return await replay(existing);
   }
   const prepared = withinDateWindow(await prepare(), options);
-  const sequence = {
-    coordinates: {
-      salesPoint: prepared.data.salesPoint,
-      voucherType: prepared.data.voucherType
-    },
-    // The sequence belongs to the taxpayer whose numbering ARCA advances.
-    taxId: String(options.representedTaxId ?? context.taxId)
-  };
-  const sequenceRecord = sequenceKey(
-    environment,
-    sequence.taxId,
-    sequence.coordinates.salesPoint,
-    sequence.coordinates.voucherType
-  );
+  const sequence = sequenceOf(environment, taxId, {
+    representedTaxId,
+    salesPoint: prepared.data.salesPoint,
+    voucherType: prepared.data.voucherType
+  });
   if (!store.withLock) {
     return await claim();
   }
   return await store.withLock(
-    sequenceLockKey(
-      environment,
-      sequence.taxId,
-      sequence.coordinates.salesPoint,
-      sequence.coordinates.voucherType
-    ),
+    sequence.lock,
     async () => {
+      const prior = await storeCall(() => store.get(key));
+      if (prior !== null) {
+        return await replay(prior, true);
+      }
       const barrier = await runSequenceBarrier({
         store,
         environment,
         taxId,
-        sequence: sequenceRecord,
+        sequence: sequence.marker,
         sequenceTaxId: sequence.taxId,
-        coordinates: sequence.coordinates,
         select: select ?? (() => wsfe),
         options,
         supersededBy: idempotencyKey,
-        readNext: () => nextNumber(wsfe, prepared.data, options)
+        readNext: () => nextNumber(wsfe, prepared.data, { ...options, number: void 0 })
       });
       return "blocked" in barrier ? {
         ...barrier.blocked,
         ...requestEvidence(prepared.data, void 0, options)
       } : await claim(barrier.reserved);
-    }
+    },
+    // The deadline also bounds the wait: giving up there reserved nothing.
+    { signal: options.abortSignal }
   );
   function reservation(number) {
     const service = options.service ?? "wsfe";
@@ -3937,10 +3929,6 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
   }
   async function claim(reserved) {
     const coordinated = store.withLock !== void 0;
-    const prior = coordinated ? await storeCall(() => store.get(key)) : null;
-    if (prior !== null) {
-      return await replay(prior, true);
-    }
     const number = options.number ?? reserved ?? await nextNumber(wsfe, prepared.data, options);
     const record = reservation(number);
     const claimed = {
@@ -3951,21 +3939,20 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
       claimedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (coordinated) {
-      await storeCall(() => store.set(sequenceRecord, JSON.stringify(claimed)));
+      await storeCall(
+        () => store.set(sequence.marker, JSON.stringify(claimed))
+      );
     }
     if (await storeCall(() => store.add(key, JSON.stringify(record)))) {
-      const outcome = await settle2(
-        runAuthorization(wsfe, prepared, options, issuer, number)
+      return await settle2(
+        record,
+        runAuthorization(wsfe, prepared, options, issuer, number, {
+          strangerAtNumber: true
+        }),
+        // Without the lock, a retry of this key may write the number while
+        // this claim is still in flight: its 10016 is not marked.
+        { written: claimed, everyRejected: true, racing: !coordinated }
       );
-      if (coordinated && outcome.kind !== "indeterminate") {
-        await storeCall(
-          () => store.set(
-            sequenceRecord,
-            JSON.stringify({ ...claimed, resolvedAt: (/* @__PURE__ */ new Date()).toISOString() })
-          )
-        );
-      }
-      return outcome;
     }
     const winner = await storeCall(() => store.get(key));
     if (winner === null) {
@@ -3986,51 +3973,157 @@ async function runOperation(wsfe, operation, input, prepare, options, context, r
         }
       );
     }
-    const consult = async () => {
-      const recorded = await storeCall(() => store.get(settled));
-      if (recorded !== null) {
-        return await settledOutcome(
-          select ?? (() => wsfe),
-          stored,
-          readSettledRecord(recorded),
-          options,
-          taxId,
-          (owner, other) => storeCall(() => store.get(settledKey(environment, owner, other)))
-        );
+    return await consultKey(
+      { store, environment, taxId, idempotencyKey },
+      stored,
+      locked,
+      select ?? (() => wsfe),
+      options,
+      resend
+    );
+  }
+  async function resend(current) {
+    const rejected = current.rejectedAt !== void 0;
+    if (rejected) {
+      const held = await clearRejection(current);
+      if (held !== void 0) {
+        return held;
       }
-      return await settle2(
-        runAuthorization(
-          wsfe,
-          {
-            ...preparedFromRecord(stored),
-            ...replayAmounts ? { amounts: replayAmounts } : {}
-          },
-          options,
-          issuer,
-          stored.number,
-          true
-        )
-      );
-    };
-    if (locked || !store.withLock) {
-      return await consult();
     }
-    return await store.withLock(
-      sequenceLockKey(
-        environment,
-        stored.representedTaxId ?? taxId,
-        stored.salesPoint,
-        stored.voucherType
+    return await settle2(
+      current,
+      runAuthorization(
+        wsfe,
+        {
+          ...preparedFromRecord(current),
+          ...replayAmounts ? { amounts: replayAmounts } : {}
+        },
+        options,
+        issuer,
+        current.number,
+        { lookupFirst: !rejected, strangerAtNumber: rejected }
       ),
-      consult
+      { everyRejected: rejected, presumed: rejected, racing: rejected }
+    );
+  }
+  async function settle2(record, running, {
+    written,
+    everyRejected = false,
+    presumed = false,
+    racing = false
+  } = {}) {
+    const uncoordinated = !store.withLock;
+    const outcome = await recordConflict(
+      store,
+      settled,
+      await running,
+      !(presumed && uncoordinated)
+    );
+    const marks = outcome.kind === "rejected" && everyRejected && !(uncoordinated && racing && mayHoldNumber(outcome.issues, record.service));
+    if (marks) {
+      const rejected = { ...record, rejectedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      await storeCall(() => store.set(key, JSON.stringify(rejected)));
+    }
+    if (!store.withLock || outcome.kind === "indeterminate" || outcome.kind === "rejected" && !marks) {
+      return outcome;
+    }
+    const { marker } = sequenceOf(environment, taxId, record);
+    const json = written ? null : await storeCall(() => store.get(marker));
+    const claimed = written ?? (json === null ? null : readSequenceRecord(json));
+    if (claimed !== null && isOwnClaim(claimed) && claimed.number === record.number && claimed.resolvedAt === void 0) {
+      const resolved = { ...claimed, resolvedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      await storeCall(() => store.set(marker, JSON.stringify(resolved)));
+    }
+    return outcome;
+  }
+  async function clearRejection(record) {
+    const checked = await settle2(
+      record,
+      consultReservation(select ?? (() => wsfe), record, options, taxId, true),
+      { presumed: true }
     );
+    if (checked.kind !== "indeterminate" || checked.lookup.kind !== "not_found") {
+      return checked;
+    }
+    const holder = await reclaim(record);
+    if (holder !== void 0) {
+      return withheld(
+        record,
+        { kind: "blocked", by: holder.key, byTaxId: holder.issuerTaxId },
+        options
+      );
+    }
+    const { rejectedAt: _, ...pending } = record;
+    await storeCall(() => store.set(key, JSON.stringify(pending)));
   }
-  async function settle2(running) {
-    return await recordConflict(store, settled, await running);
+  async function reclaim(record) {
+    if (!store.withLock) {
+      return;
+    }
+    const { marker } = sequenceOf(environment, taxId, record);
+    const json = await storeCall(() => store.get(marker));
+    const claimed = json === null ? null : readSequenceRecord(json);
+    if (claimed !== null && !isOwnClaim(claimed) && claimed.resolvedAt === void 0) {
+      return { key: claimed.key, issuerTaxId: claimed.issuerTaxId ?? taxId };
+    }
+    const reopened = {
+      v: 1,
+      key: idempotencyKey,
+      issuerTaxId: taxId,
+      number: record.number,
+      claimedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await storeCall(() => store.set(marker, JSON.stringify(reopened)));
   }
+  function isOwnClaim(claimed) {
+    return claimed.key === idempotencyKey && (claimed.issuerTaxId ?? taxId) === taxId;
+  }
+}
+function sequenceOf(environment, taxId, {
+  representedTaxId,
+  salesPoint,
+  voucherType
+}) {
+  const owner = representedTaxId ?? taxId;
+  return {
+    taxId: owner,
+    marker: sequenceKey(environment, owner, salesPoint, voucherType),
+    lock: sequenceLockKey(environment, owner, salesPoint, voucherType)
+  };
 }
-async function recordConflict(store, key, outcome) {
-  if (outcome.kind !== "conflict") {
+async function consultKey({ store, environment, taxId, idempotencyKey }, stored, locked, select, options, unrecorded) {
+  const consult = async (current) => {
+    const recorded = await storeCall(
+      () => store.get(settledKey(environment, taxId, idempotencyKey))
+    );
+    if (recorded === null) {
+      return await unrecorded(current);
+    }
+    return await settledOutcome(
+      select,
+      current,
+      readSettledRecord(recorded),
+      options,
+      taxId,
+      (owner, other) => storeCall(() => store.get(settledKey(environment, owner, other)))
+    );
+  };
+  if (locked || !store.withLock) {
+    return await consult(stored);
+  }
+  return await store.withLock(
+    sequenceOf(environment, taxId, stored).lock,
+    async () => {
+      const json = await storeCall(
+        () => store.get(attemptKey(environment, taxId, idempotencyKey))
+      );
+      return await consult(json === null ? stored : readRecord(json));
+    },
+    { signal: options.abortSignal }
+  );
+}
+async function recordConflict(store, key, outcome, durable = true) {
+  if (outcome.kind !== "conflict" || !durable) {
     return outcome;
   }
   const record = {
@@ -4077,26 +4170,33 @@ async function settledOutcome(select, reservation, settled, options, taxId, sett
   if (!empty && (outcome.kind !== "conflict" || await successionDisputed(settled, taxId, settledFor))) {
     return outcome;
   }
+  return withheld(
+    reservation,
+    { kind: "superseded", by: settled.by, byTaxId: settled.byTaxId ?? taxId },
+    options,
+    settled.number
+  );
+}
+function withheld(reservation, lookup, options, number = reservation.number) {
   return {
     kind: "indeterminate",
     attempted: {
       salesPoint: reservation.salesPoint,
       voucherType: reservation.voucherType,
-      number: settled.number
+      number
     },
     attempt: replayEvidence(reservation.service),
-    lookup: {
-      kind: "superseded",
-      by: settled.by,
-      byTaxId: settled.byTaxId ?? taxId
-    },
-    ...requestEvidence(
-      preparedFromRecord(reservation).data,
-      reservation.number,
-      { ...options, service: reservation.service ?? "wsfe" }
-    )
+    lookup,
+    ...reservationEvidence(reservation, options)
   };
 }
+function reservationEvidence(reservation, options) {
+  return requestEvidence(
+    preparedFromRecord(reservation).data,
+    reservation.number,
+    { ...options, service: reservation.service ?? "wsfe" }
+  );
+}
 async function successionDisputed(superseded, taxId, settledFor) {
   let owner = superseded.byTaxId ?? taxId;
   let next = superseded.by;
@@ -4125,11 +4225,7 @@ function settledConflict(settled, reservation, options) {
     attempt: replayEvidence(reservation.service),
     found: settled.found,
     reason: "This key already recorded another voucher at the reserved number. Reconcile before issuing under a new key.",
-    ...requestEvidence(
-      preparedFromRecord(reservation).data,
-      reservation.number,
-      { ...options, service: reservation.service ?? "wsfe" }
-    )
+    ...reservationEvidence(reservation, options)
   };
 }
 function validateKeyStore(options, context) {
@@ -4151,7 +4247,7 @@ function validateKeyStore(options, context) {
 function readRecord(json) {
   try {
     const record = JSON.parse(json);
-    if (!record || record.v !== 1 && record.v !== 2 || record.v === 2 && record.service === void 0 || !["issue", "creditNote", "debitNote"].includes(record.operation) || typeof record.inputHash !== "string" || !record.sent || !Number.isSafeInteger(record.number) || record.number < 1 || record.number > 99999999 || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
+    if (!record || record.v !== 1 && record.v !== 2 || record.v === 2 && record.service === void 0 || !["issue", "creditNote", "debitNote"].includes(record.operation) || typeof record.inputHash !== "string" || !record.sent || record.rejectedAt !== void 0 && typeof record.rejectedAt !== "string" || !Number.isSafeInteger(record.number) || record.number < 1 || record.number > 99999999 || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
       throw new Error("Invalid reservation structure");
     }
     normalizeWsfeVoucherInput(record.sent);
@@ -4201,7 +4297,7 @@ async function nextNumber(wsfe, data, options) {
   }
   return number;
 }
-async function runAuthorization(wsfe, { data, voucherClass, amounts }, options, taxId, reservedNumber, replay = false) {
+async function runAuthorization(wsfe, { data, voucherClass, amounts }, options, taxId, reservedNumber, { lookupFirst = false, strangerAtNumber = false } = {}) {
   const auth = {
     representedTaxId: options.representedTaxId,
     forceRefresh: options.forceRefresh,
@@ -4231,7 +4327,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
     voucher,
     service: options.service
   };
-  if (replay) {
+  if (lookupFirst) {
     const attempt2 = replayEvidence(options.service);
     let lookup;
     try {
@@ -4277,7 +4373,7 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
       recovery,
       options,
       includeRawResponse,
-      replay
+      strangerAtNumber
     );
   }
   const uncertain = authorization.kind === "indeterminate" ? authorization : {
@@ -4298,9 +4394,9 @@ async function runAuthorization(wsfe, { data, voucherClass, amounts }, options,
     voucher
   });
 }
-async function resolveRejection(authorization, recovery, options, includeRawResponse, replay) {
+async function resolveRejection(authorization, recovery, options, includeRawResponse, strangerAtNumber) {
   const issues = [...authorization.errors, ...authorization.observations];
-  const consult = options.idempotencyKey !== void 0 && (options.service === "wsmtxca" || issues.some((issue) => issue.code === "10016"));
+  const consult = options.idempotencyKey !== void 0 && mayHoldNumber(issues, options.service);
   if (consult) {
     const recovered = await recoverInvoice({
       ...recovery,
@@ -4312,7 +4408,7 @@ async function resolveRejection(authorization, recovery, options, includeRawResp
         },
         includeRawResponse
       ),
-      strangerAtNumber: !replay
+      strangerAtNumber
     });
     if (recovered.kind === "authorized" || recovered.kind === "conflict") {
       return recovered;
@@ -4326,6 +4422,9 @@ async function resolveRejection(authorization, recovery, options, includeRawResp
     ...recovery.includedRequest
   };
 }
+function mayHoldNumber(issues, service = "wsfe") {
+  return service === "wsmtxca" || issues.some((issue) => issue.code === "10016");
+}
 async function recoverInvoice({
   wsfe,
   auth,
@@ -4376,7 +4475,7 @@ async function recoverInvoice({
       attempted,
       attempt,
       found: { ...toVoucherSummary(lookup.voucher), ...rawResponse },
-      reason: "ARCA refused the number this call reserved and another voucher occupies it",
+      reason: "This key never wrote the number it reserved, and another voucher occupies it",
       ...includedRequest
     };
   }
@@ -4816,14 +4915,10 @@ async function recoverOperation(select, key, inputOptions, context) {
   );
   validateOptions(options);
   validateKeyStore({ ...options, idempotencyKey: key }, context);
+  const scope = keyScope(context, key);
+  const { store, environment, taxId } = scope;
   const json = await storeCall(
-    () => context.store.get(
-      attemptKey(
-        context.environment,
-        context.taxId,
-        key
-      )
-    )
+    () => store.get(attemptKey(environment, taxId, key))
   );
   if (json === null) {
     throw new ArcaInputError("No reservation exists for this idempotency key", {
@@ -4832,44 +4927,40 @@ async function recoverOperation(select, key, inputOptions, context) {
     });
   }
   const record = readRecord(json);
-  const store = context.store;
-  const settled = settledKey(
-    context.environment,
-    context.taxId,
-    key
-  );
-  if (options.representedTaxId !== void 0 && String(options.representedTaxId) !== (record.representedTaxId ?? context?.taxId)) {
+  if (options.representedTaxId !== void 0 && String(options.representedTaxId) !== (record.representedTaxId ?? taxId)) {
     throw new ArcaInputError(
       "Reservation belongs to another represented taxpayer",
       { code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH" }
     );
   }
-  const recorded = await storeCall(() => store.get(settled));
-  if (recorded !== null) {
-    return await settledOutcome(
-      select,
-      record,
-      readSettledRecord(recorded),
-      options,
-      context.taxId,
-      (owner, other) => storeCall(
-        () => store.get(
-          settledKey(context.environment, owner, other)
-        )
-      )
-    );
-  }
-  return await recordConflict(
-    store,
-    settled,
-    await consultReservation(
-      select,
-      record,
-      options,
-      context.taxId
-    )
+  return await consultKey(
+    scope,
+    record,
+    false,
+    select,
+    options,
+    async (current) => {
+      const rejected = current.rejectedAt !== void 0;
+      return await recordConflict(
+        store,
+        settledKey(environment, taxId, key),
+        await consultReservation(select, current, options, taxId, rejected),
+        !rejected || store.withLock !== void 0
+      );
+    }
   );
 }
+function keyScope(context, idempotencyKey) {
+  if (!context?.store) {
+    throw new ArcaConfigurationError("idempotencyKey requires a store.");
+  }
+  return {
+    store: context.store,
+    environment: context.environment,
+    taxId: context.taxId,
+    idempotencyKey
+  };
+}
 function consultReservation(select, record, options, taxId, strangerAtNumber = false) {
   const storedOptions = {
     ...options,
@@ -4995,7 +5086,6 @@ async function runSequenceBarrier({
   taxId,
   sequence,
   sequenceTaxId,
-  coordinates,
   select,
   options,
   supersededBy,
@@ -5021,13 +5111,15 @@ async function runSequenceBarrier({
     return {};
   }
   const record = readRecord(reservation);
+  if (record.rejectedAt !== void 0) {
+    return {};
+  }
   const blocked = {
-    blocked: {
-      kind: "indeterminate",
-      attempted: { ...coordinates, number: record.number },
-      attempt: replayEvidence(options.service),
-      lookup: { kind: "blocked", by: claimed.key, byTaxId: owner }
-    }
+    blocked: withheld(
+      record,
+      { kind: "blocked", by: claimed.key, byTaxId: owner },
+      options
+    )
   };
   const outcome = await recordConflict(
     store,
@@ -5054,6 +5146,9 @@ async function runSequenceBarrier({
   if (outcome.kind !== "indeterminate" || outcome.lookup.kind !== "not_found") {
     return blocked;
   }
+  if (options.number !== void 0 && options.number !== record.number) {
+    return blocked;
+  }
   const next = await readNext();
   if (next !== record.number) {
     return blocked;
@@ -5344,19 +5439,26 @@ var ARCA_LEASE_MS = 6e4;
 var RENEW_MS = 2e4;
 var POLL_MS = 50;
 var MAX_WAIT_MS = 2 * ARCA_LEASE_MS;
-async function withLease(key, driver, fn) {
+async function withLease(key, driver, fn, { signal } = {}) {
   const owner = randomUUID();
   const deadline = Date.now() + MAX_WAIT_MS;
+  throwIfAborted(key, signal);
   let held = await driver.acquire(owner);
   while (!held) {
     if (Date.now() >= deadline) {
-      throw new ArcaConfigurationError(
-        `ARCA store lock ${key} stayed held; no work was attempted.`
+      throw new ArcaLockTimeoutError(
+        `ARCA store lock ${key} stayed held; no work was attempted.`,
+        { reason: "held" }
       );
     }
-    await delay2(POLL_MS + Math.floor(Math.random() * POLL_MS));
+    await delay2(POLL_MS + Math.floor(Math.random() * POLL_MS), signal);
+    throwIfAborted(key, signal);
     held = await driver.acquire(owner);
   }
+  if (signal?.aborted) {
+    await driver.release(owner).catch(() => void 0);
+    throwIfAborted(key, signal);
+  }
   const renewal = setInterval(() => {
     driver.renew(owner).catch(() => void 0);
   }, RENEW_MS);
@@ -5368,10 +5470,29 @@ async function withLease(key, driver, fn) {
     await driver.release(owner).catch(() => void 0);
   }
 }
-function delay2(ms) {
+function throwIfAborted(key, signal) {
+  if (signal?.aborted) {
+    throw new ArcaLockTimeoutError(
+      `Stopped waiting for ARCA store lock ${key}: the caller's signal aborted; no work was attempted.`,
+      { reason: "aborted", cause: signal.reason }
+    );
+  }
+}
+function delay2(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve();
+  }
   return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
+    const wake = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", wake);
+      resolve();
+    }, ms);
     timer.unref?.();
+    signal?.addEventListener("abort", wake, { once: true });
   });
 }
 
@@ -5421,10 +5542,10 @@ function createFileStore(directory) {
         }
       }
     }),
-    withLock: (key, fn) => (
+    withLock: (key, fn, options) => (
       // A lock directory: mkdir is the atomic claim on every POSIX filesystem
       // and on Windows, and the holder file inside carries the lease.
-      withLease(key, fileLease(`${path(key)}.lock`, ensure), fn)
+      withLease(key, fileLease(`${path(key)}.lock`, ensure), fn, options)
     )
   };
 }
@@ -5600,12 +5721,14 @@ export {
   arcaQrPayload,
   voucherDateWindow,
   matchWsfeVoucherIdentity,
+  abortable,
   createMemoryWsaaSessionStore,
   createWsaaAuthModule,
   createWsaaStoreAdapter,
   createArcaClient,
   ARCA_LEASE_MS,
   withLease,
+  throwIfAborted,
   createFileStore
 };
-//# sourceMappingURL=chunk-CYXS3F34.mjs.map
+//# sourceMappingURL=chunk-WEEV76IC.mjs.map