@openreceive/browser 0.1.0 → 0.2.1

package/dist/headless.js

@@ -0,0 +1,932 @@
+import {
+  BrowserRequestError,
+  OPENRECEIVE_CHECKOUT_DATA_ATTRIBUTES,
+  OPENRECEIVE_CHECKOUT_DATA_SELECTORS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES,
+  OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_PARTS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_PART_SELECTORS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_TAG_NAME,
+  OPENRECEIVE_COPY_FEEDBACK_MS,
+  OPENRECEIVE_DEFAULT_POLL_INTERVAL_MS,
+  OPENRECEIVE_DEFAULT_PREFIX,
+  OPENRECEIVE_PAYMENT_WIZARD_ATTRIBUTES,
+  OPENRECEIVE_PAYMENT_WIZARD_SELECTORS,
+  OPENRECEIVE_THEME_STORAGE_KEY,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_EVENTS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_PARTS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_PART_SELECTORS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_TAG_NAME,
+  assertDisplayInvoice,
+  assetButtonClasses,
+  buildMethodGridEntries,
+  checkoutElementStyles,
+  checkoutLabels,
+  checkoutRoutes,
+  copyInvoice,
+  createBlockExplorerUrl,
+  createCheckoutActionEvent,
+  createCheckoutController,
+  createCheckoutErrorEvent,
+  createCheckoutProviderCopyEvent,
+  createCheckoutSnapshotFromInvoice,
+  createCheckoutState,
+  createCheckoutStateEvent,
+  createCheckoutStatusModel,
+  createDetailExternalLink,
+  createLightningInvoiceDecodeUrl,
+  createPaymentDataEntries,
+  createPaymentWizardController,
+  createPaymentWizardModel,
+  createPaymentWizardSelection,
+  createQrPayloadSvg,
+  createQrSvg,
+  createStatusFetcher,
+  createSwapDisplayModel,
+  createSwapUnavailableModel,
+  createThemeChangeEvent,
+  createTickingValueController,
+  createTransactionDetails,
+  createTransactionDetailsFromState,
+  createTransientFeedbackController,
+  createWizardRouteAssetDisplays,
+  createWizardRouteDisplays,
+  deriveCheckoutStateLabels,
+  deriveStatus,
+  enterCheckoutResumePath,
+  escapeHtml,
+  findSwapGridGroup,
+  formatAmountCaption,
+  formatChooseNetworkHeading,
+  formatDepositAmount,
+  formatFiatAmount,
+  formatMsats,
+  formatNetworkSummary,
+  formatSwapLimit,
+  formatUnixTime,
+  getExplorerNetwork,
+  getNetworkIcon,
+  getPaymentMethodIcon,
+  getRouteNetworkLabel,
+  getSwapOptionIcon,
+  getSwapRefundFormError,
+  getWizardEmptyMessage,
+  isPaidCheckoutSnapshot,
+  isReusableLightningInvoice,
+  networkButtonClasses,
+  networkCheckClasses,
+  networkMobileRevealClasses,
+  networkSummaryIconClasses,
+  openWallet,
+  optionalSafeInteger,
+  orClasses,
+  overlaySwapRefundStaging,
+  parseBooleanAttribute,
+  parseMethodPickerKey,
+  parseOptionalInteger,
+  parsePaymentMethod,
+  parseResolvedTheme,
+  parseThemePreference,
+  paymentAccentId,
+  paymentIconUrls,
+  paymentMethods,
+  prepareCheckout,
+  readJsonResponse,
+  requestCheckout,
+  requestHeaders,
+  resolveBrowserLogger,
+  resolvePreservedNetworkSelection,
+  resolveTransactionDetailRows,
+  sanitizeBrowserLogEntry,
+  selectCheckoutDisplayInvoice,
+  swapAssetMatchesRoute,
+  swapGroupLimitOption,
+  swapOptionLimitMessage,
+  swapPickerKey,
+  updatePaymentWizardSelection,
+  updateSelectedSwapNetworks,
+  wizardNetworkGroupIds
+} from "./chunk-V7C55QB2.js";
+
+// src/internal/checkout-merge.ts
+function findReusableLightningInvoice(snapshot, now) {
+  return snapshot.invoices.find(
+    (invoice) => invoice.rail === "lightning" && typeof invoice.invoice === "string" && invoice.invoice.length > 0 && invoice.expires_at !== void 0 && isReusableLightningInvoice(invoice.expires_at, now)
+  );
+}
+function mergeAttemptIntoSnapshot(invoice, base) {
+  const withoutSame = base.invoices.filter(
+    (entry) => entry.invoice_id !== invoice.invoice_id && entry.rail !== "checkout_lock"
+  );
+  return {
+    ...base,
+    checkout_id: invoice.invoice_id,
+    active: invoice,
+    invoices: [invoice, ...withoutSame],
+    ...invoice.amount_msats === void 0 ? {} : { amount_msats: invoice.amount_msats }
+  };
+}
+function mergeAttemptIntoCheckout(invoice, previous, reference) {
+  const base = previous ?? {
+    checkout_id: invoice.invoice_id,
+    reference,
+    status: "open",
+    amount_msats: invoice.amount_msats ?? 0,
+    invoices: []
+  };
+  return mergeAttemptIntoSnapshot(invoice, base);
+}
+function mergeMintedCheckout(checkout, previous) {
+  const minted = selectCheckoutDisplayInvoice(checkout) ?? checkout.active;
+  if (minted === void 0) {
+    return {
+      ...checkout,
+      ...previous?.payment_methods === void 0 ? {} : { payment_methods: previous.payment_methods }
+    };
+  }
+  if (previous === void 0) return mergeAttemptIntoSnapshot(minted, checkout);
+  return mergeAttemptIntoSnapshot(minted, {
+    ...previous,
+    ...checkout,
+    invoices: previous.invoices,
+    payment_methods: previous.payment_methods ?? checkout.payment_methods
+  });
+}
+
+// src/internal/checkout-props.ts
+var CREATE_MODE_ONLY_PROPS = [
+  "metadata",
+  "syncUrl",
+  "resumePathPrefix",
+  "routeReference"
+];
+var warnedSnapshotModeProps = /* @__PURE__ */ new Set();
+function validateCheckoutProps(props) {
+  const snapshot = props.checkout ?? null;
+  if (snapshot === null && (props.reference === void 0 || props.reference.length === 0)) {
+    throw new TypeError(
+      `${props.framework} Checkout requires a checkout snapshot or a reference (create mode).`
+    );
+  }
+  if (snapshot === null) return;
+  const ignored = CREATE_MODE_ONLY_PROPS.filter((name) => props[name] !== void 0);
+  if (ignored.length === 0) return;
+  const key = `${props.framework}:${ignored.join(",")}`;
+  if (warnedSnapshotModeProps.has(key)) return;
+  warnedSnapshotModeProps.add(key);
+  const warn = props.warn ?? ((message) => globalThis.console?.warn?.(message));
+  warn(
+    `${props.framework} Checkout ignores ${ignored.join(", ")} in snapshot mode; those props only apply when the component creates the checkout from a reference.`
+  );
+}
+
+// src/internal/checkout-session.ts
+import { recordOrEmpty as recordOrEmpty2 } from "@openreceive/core";
+
+// src/internal/swap-http.ts
+import { nonEmptyString, recordOrEmpty } from "@openreceive/core";
+async function postJson(options) {
+  const { body } = options;
+  const routes = checkoutRoutes(options.prefix);
+  const reference = nonEmptyString(body.reference);
+  const action = nonEmptyString(body.action);
+  if (action !== void 0 && action !== "swap_quote" && action !== "refund_swap") {
+    throw new Error(`Unrecognized checkout action ${action}.`);
+  }
+  emitSwapActionLog(options.logger, "requested", body);
+  try {
+    const result = action === "swap_quote" ? await requestJson(options, routes.swapsQuote, {
+      reference,
+      pay_in_asset: body.pay_in_asset
+    }) : action === "refund_swap" ? await refundRequest(options, routes, body, reference) : await requestJson(options, routes.paymentsCheck, withoutAction(body));
+    if (action === "refund_swap") {
+      emitSwapActionLog(options.logger, "succeeded", body, swapActionResultFields(result));
+    }
+    return result;
+  } catch (error) {
+    emitSwapActionLog(options.logger, "failed", body, {
+      error_message: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function normalizeSwapStartInvoice(body) {
+  const outer = recordOrEmpty(body);
+  const swap = recordOrEmpty(outer.swap ?? body);
+  const checkout = recordOrEmpty(swap.checkout);
+  const paymentHash = nonEmptyString(swap.payment_hash ?? checkout.payment_hash);
+  if (paymentHash === void 0 || nonEmptyString(swap.provider) === void 0 || nonEmptyString(swap.pay_in_asset) === void 0 || nonEmptyString(swap.deposit_address) === void 0 || nonEmptyString(swap.deposit_amount) === void 0 || nonEmptyString(swap.provider_state) === void 0 || typeof swap.provider_expires_at !== "number") {
+    throw new Error("Swap response did not include provider instructions.");
+  }
+  const amountMsats = optionalSafeInteger(checkout.amount_msats, "amount_msats");
+  return {
+    invoice_id: paymentHash,
+    rail: "swap",
+    payment_hash: paymentHash,
+    ...amountMsats === void 0 ? {} : { amount_msats: amountMsats },
+    transaction_state: "pending",
+    workflow_state: "invoice_created",
+    expires_at: swap.provider_expires_at,
+    swap: {
+      provider: swap.provider,
+      pay_in_asset: swap.pay_in_asset,
+      deposit_address: swap.deposit_address,
+      deposit_amount: swap.deposit_amount,
+      provider_state: swap.provider_state,
+      provider_expires_at: swap.provider_expires_at,
+      ...copyOptionalSwapFields(swap)
+    }
+  };
+}
+async function startSwapRequest(options) {
+  const logBody = {
+    action: "start_swap",
+    reference: options.reference,
+    pay_in_asset: options.payInAsset
+  };
+  emitSwapActionLog(options.logger, "requested", logBody);
+  try {
+    const body = await requestJson(options, checkoutRoutes(options.prefix).swaps, {
+      reference: options.reference,
+      pay_in_asset: options.payInAsset
+    });
+    emitSwapActionLog(options.logger, "succeeded", logBody, swapActionResultFields(body));
+    return normalizeSwapStartInvoice(body);
+  } catch (error) {
+    emitSwapActionLog(options.logger, "failed", logBody, {
+      error_message: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+async function requestSwapRefund(options) {
+  const payment = options.invoices.find(
+    (invoice) => invoice != null && (invoice.swap?.attempt_id ?? invoice.invoice_id) === options.attemptId
+  );
+  if (payment?.payment_hash === void 0) {
+    throw new Error("Swap refund requires the original payment hash.");
+  }
+  const body = await postJson({
+    fetch: options.fetch,
+    prefix: options.prefix,
+    ...options.logger === void 0 ? {} : { logger: options.logger },
+    ...options.headers === void 0 ? {} : { headers: options.headers },
+    body: {
+      ...options.reference === void 0 ? {} : { reference: options.reference },
+      payment_hash: payment.payment_hash,
+      action: "refund_swap",
+      attempt_id: options.attemptId,
+      refund_address: options.refundAddress,
+      confirm: options.confirm
+    }
+  });
+  return normalizeSwapStartInvoice(body);
+}
+async function refundRequest(options, routes, body, reference) {
+  if (reference === void 0) throw new Error("Swap refund requires reference.");
+  const refundAddress = nonEmptyString(body.refund_address);
+  if (refundAddress === void 0) throw new Error("Swap refund requires refund_address.");
+  const paymentHash = nonEmptyString(body.payment_hash);
+  if (paymentHash === void 0) throw new Error("Swap refund requires payment_hash.");
+  if (body.confirm === true) {
+    const status2 = recordOrEmpty(
+      await requestJson(options, routes.swapsRefunds, {
+        reference,
+        payment_hash: paymentHash,
+        refund_address: refundAddress
+      })
+    );
+    return { swap: status2 };
+  }
+  const status = recordOrEmpty(
+    await requestJson(options, routes.swapsStatus, {
+      reference,
+      payment_hash: paymentHash
+    })
+  );
+  return { swap: { ...status, refund_address: refundAddress } };
+}
+function withoutAction(body) {
+  const { action: _action, ...rest } = body;
+  return rest;
+}
+async function requestJson(options, url, body) {
+  const fetcher = options.fetch;
+  const response = await fetcher(url, {
+    method: "POST",
+    headers: requestHeaders(options.headers),
+    body: JSON.stringify(body)
+  });
+  return readJsonResponse(response, "OpenReceive request failed.");
+}
+function copyOptionalSwapFields(swap) {
+  const output = {};
+  for (const key of [
+    "deposit_memo",
+    "deposit_tx_id",
+    "payout_tx_id",
+    "refund_tx_id",
+    "refund_reason",
+    "refund_amount",
+    "attention",
+    "attempt_id",
+    "provider_order_id",
+    "refund_address",
+    "attention_reason",
+    "deposit_received_amount",
+    "fee"
+  ]) {
+    if (swap[key] !== void 0) output[key] = swap[key];
+  }
+  return output;
+}
+function emitSwapActionLog(logger, outcome, body, extra = {}) {
+  const sink = resolveBrowserLogger(logger);
+  if (sink === void 0) return;
+  const action = nonEmptyString(body.action);
+  if (action !== "start_swap" && action !== "refund_swap") return;
+  const event = action === "start_swap" ? `swap.start.${outcome}` : `swap.refund.${outcome}`;
+  const level = outcome === "failed" ? "warn" : outcome === "requested" ? "debug" : "info";
+  try {
+    sink(
+      sanitizeBrowserLogEntry({
+        level,
+        event,
+        message: `${action === "start_swap" ? "Swap start" : "Swap refund"} ${outcome}.`,
+        reference: nonEmptyString(body.reference),
+        pay_in_asset: nonEmptyString(body.pay_in_asset),
+        ...action === "refund_swap" ? { confirm: body.confirm === true } : {},
+        ...extra
+      })
+    );
+  } catch {
+  }
+}
+function swapActionResultFields(body) {
+  const swap = recordOrEmpty(recordOrEmpty(body).swap ?? body);
+  return {
+    payment_hash: nonEmptyString(swap.payment_hash),
+    provider_state: nonEmptyString(swap.provider_state),
+    attention: typeof swap.attention === "boolean" ? swap.attention : void 0
+  };
+}
+
+// src/internal/checkout-session.ts
+var SWAP_START_FAILED = "Could not prepare the payment address. Please try again.";
+var MINT_FAILED = "Could not create the Lightning invoice. Please try again.";
+function normalizeSwapQuote(body) {
+  const quote = recordOrEmpty2(recordOrEmpty2(body).quote ?? body);
+  const payInAsset = quote.pay_in_asset ?? quote.pay_asset;
+  return typeof payInAsset === "string" ? { ...quote, pay_in_asset: payInAsset } : void 0;
+}
+function payerFacingMessage(error, fallback) {
+  return error instanceof Error && error.message.length > 0 ? error.message : fallback;
+}
+function createCheckoutSession(options) {
+  let wizardError;
+  let swapStartError;
+  let lightningRequested = false;
+  let mintingLightning = false;
+  let startingSwapAsset = null;
+  let swapQuotes = {};
+  async function ensureLightning() {
+    if (mintingLightning) return;
+    const reference = options.reference();
+    if (reference === void 0 || reference.length === 0) return;
+    const current = options.snapshot();
+    if (current !== void 0) {
+      const reusableLightning = findReusableLightningInvoice(current);
+      if (reusableLightning !== void 0) {
+        lightningRequested = true;
+        options.onSnapshot?.(mergeAttemptIntoSnapshot(reusableLightning, current));
+        options.onChange();
+        return;
+      }
+    }
+    mintingLightning = true;
+    wizardError = void 0;
+    options.onChange();
+    try {
+      const pending = options.requestCheckout?.(reference);
+      if (pending === void 0) return;
+      const checkout = await pending;
+      lightningRequested = true;
+      options.onSnapshot?.(mergeMintedCheckout(checkout, options.snapshot()));
+    } catch (error) {
+      wizardError = payerFacingMessage(error, MINT_FAILED);
+      options.onError(error);
+    } finally {
+      mintingLightning = false;
+      options.onChange();
+    }
+  }
+  async function startSwap(payInAsset) {
+    if (startingSwapAsset !== null) return;
+    const selection = options.swapSelection;
+    const prefix = options.swapPrefix?.();
+    const fetcher = options.fetch?.();
+    const reference = options.reference();
+    if (selection === void 0 || prefix === void 0 || fetcher === void 0) return;
+    if (reference === void 0 || reference.length === 0) return;
+    const alreadyStarted = selection.started();
+    if (alreadyStarted?.swap?.pay_in_asset === payInAsset && alreadyStarted.invoice_id !== selection.dismissedInvoiceId()) {
+      selection.setSelectedAsset(payInAsset);
+      options.onChange();
+      return;
+    }
+    startingSwapAsset = payInAsset;
+    swapStartError = void 0;
+    options.onChange();
+    try {
+      const quote = await quoteSwapAsset(payInAsset, prefix, fetcher, reference);
+      if (quote !== void 0 && quote.available === false) return;
+      const started = await startSwapRequest({
+        fetch: fetcher,
+        prefix,
+        reference,
+        payInAsset,
+        ...options.logger === void 0 ? {} : { logger: options.logger }
+      });
+      selection.setStarted(started);
+      selection.setDismissedInvoiceId(null);
+      options.onSwapStarted?.(started);
+      selection.setSelectedAsset(payInAsset);
+      options.onChange();
+    } catch (error) {
+      const landed = selection.started();
+      if (landed?.swap?.pay_in_asset === payInAsset && landed.invoice_id !== selection.dismissedInvoiceId()) {
+        selection.setSelectedAsset(payInAsset);
+        options.onChange();
+        return;
+      }
+      selection.setSelectedAsset(payInAsset);
+      failSwapStart(error);
+    } finally {
+      startingSwapAsset = null;
+    }
+  }
+  async function quoteSwapAsset(payInAsset, prefix, fetcher, reference) {
+    const body = await postJson({
+      fetch: fetcher,
+      prefix,
+      ...options.logger === void 0 ? {} : { logger: options.logger },
+      body: { reference, action: "swap_quote", pay_in_asset: payInAsset }
+    });
+    const quote = normalizeSwapQuote(body);
+    if (quote === void 0) return void 0;
+    swapQuotes = { ...swapQuotes, [quote.pay_in_asset]: quote };
+    return quote;
+  }
+  function failSwapStart(error) {
+    swapStartError = payerFacingMessage(error, SWAP_START_FAILED);
+    options.onError(error);
+    options.onChange();
+  }
+  return {
+    get wizardError() {
+      return wizardError;
+    },
+    get swapStartError() {
+      return swapStartError;
+    },
+    get lightningRequested() {
+      return lightningRequested;
+    },
+    get mintingLightning() {
+      return mintingLightning;
+    },
+    get startingSwapAsset() {
+      return startingSwapAsset;
+    },
+    get swapQuotes() {
+      return swapQuotes;
+    },
+    ensureLightning,
+    startSwap,
+    resetLightningRequest() {
+      lightningRequested = false;
+    },
+    clearSwapStartError() {
+      swapStartError = void 0;
+    }
+  };
+}
+
+// src/internal/theme.ts
+function readThemePreference(options = {}) {
+  const value = readStorageValue(
+    options.storage ?? getBrowserStorage(),
+    options.storageKey ?? OPENRECEIVE_THEME_STORAGE_KEY
+  );
+  return value === "light" || value === "dark" || value === "system" ? value : options.defaultTheme ?? "system";
+}
+function writeThemePreference(theme, options = {}) {
+  writeStorageValue(
+    options.storage ?? getBrowserStorage(),
+    options.storageKey ?? OPENRECEIVE_THEME_STORAGE_KEY,
+    theme
+  );
+}
+function resolveTheme(theme, options = {}) {
+  if (theme === "light" || theme === "dark") return theme;
+  if (options.systemDark !== void 0) return options.systemDark ? "dark" : "light";
+  return globalThis.matchMedia?.("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function getNextThemePreference(theme, options = {}) {
+  return resolveTheme(theme, options) === "dark" ? "light" : "dark";
+}
+function getThemeToggleLabel(resolvedTheme) {
+  return `${resolvedTheme} mode`;
+}
+function createThemeModel(theme, options = {}) {
+  const resolvedTheme = resolveTheme(theme, options);
+  return {
+    theme,
+    resolvedTheme,
+    nextTheme: getNextThemePreference(theme, options),
+    toggleLabel: getThemeToggleLabel(resolvedTheme),
+    attributes: {
+      "data-theme": resolvedTheme,
+      "data-openreceive-theme": resolvedTheme
+    },
+    checkoutElementAttributes: {
+      theme: resolvedTheme
+    }
+  };
+}
+function createStoredThemeModel(options = {}) {
+  const theme = readThemePreference(options);
+  return createThemeModel(theme, { systemDark: options.systemDark });
+}
+function toggleStoredThemePreference(options = {}) {
+  const currentTheme = createStoredThemeModel(options);
+  writeThemePreference(currentTheme.nextTheme, options);
+  return createStoredThemeModel(options);
+}
+function applyThemeAttributes(target, theme) {
+  if (target === null || target === void 0) return;
+  for (const [name, value] of Object.entries(theme.attributes)) {
+    if (target.getAttribute(name) !== value) target.setAttribute(name, value);
+  }
+}
+function applyCheckoutThemeAttributes(target, theme) {
+  if (target === null || target === void 0) return;
+  for (const [name, value] of Object.entries(theme.checkoutElementAttributes)) {
+    if (target.getAttribute(name) !== value) target.setAttribute(name, value);
+  }
+}
+function applyThemeControls(targets, theme) {
+  applyThemeAttributes(targets.root, theme);
+  applyCheckoutThemeAttributes(targets.checkout, theme);
+  if (targets.toggle !== null && targets.toggle !== void 0) {
+    targets.toggle.textContent = theme.toggleLabel;
+  }
+}
+function syncStoredThemeControls(targets, options = {}) {
+  const theme = createStoredThemeModel(options);
+  applyThemeControls(targets, theme);
+  return theme;
+}
+function toggleStoredThemeControls(targets, options = {}) {
+  const theme = toggleStoredThemePreference(options);
+  applyThemeControls(targets, theme);
+  return theme;
+}
+function readStorageValue(storage, key) {
+  try {
+    return storage?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeStorageValue(storage, key, value) {
+  try {
+    storage?.setItem(key, value);
+  } catch {
+  }
+}
+function getBrowserStorage() {
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/internal/elements.ts
+function createModeAttributes(options) {
+  const attributes = {};
+  if (options.metadata !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.metadata] = JSON.stringify(options.metadata);
+  }
+  if (options.syncUrl === true) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.syncUrl] = "";
+  }
+  if (options.resumePathPrefix !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.resumePathPrefix] = options.resumePathPrefix;
+  }
+  if (options.routeReference !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.routeReference] = options.routeReference;
+  }
+  return attributes;
+}
+function sharedElementAttributes(options) {
+  const attributes = {};
+  const isSet = (value) => value !== void 0 && value !== null;
+  if (isSet(options.prefix)) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.prefix] = options.prefix;
+  }
+  if (isSet(options.theme)) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.theme] = options.theme;
+  }
+  if (options.paymentWizard !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.paymentWizard] = String(
+      options.paymentWizard
+    );
+  }
+  if (options.decodeLinkUrl !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.decodeLinkUrl] = options.decodeLinkUrl;
+  }
+  if (options.polling !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.polling] = String(options.polling);
+  }
+  if (options.pollIntervalMs !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.pollIntervalMs] = String(
+      options.pollIntervalMs
+    );
+  }
+  return attributes;
+}
+function createCheckoutElementAttributes(snapshot, options = {}) {
+  if (snapshot === null) {
+    if (options.reference === void 0 || options.reference.length === 0) {
+      throw new TypeError(
+        "OpenReceive checkout element create mode requires a reference when no snapshot is given."
+      );
+    }
+    return {
+      [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.reference]: options.reference,
+      ...sharedElementAttributes(options),
+      ...createModeAttributes(options)
+    };
+  }
+  const displayInvoice = selectCheckoutDisplayInvoice(snapshot);
+  const bolt11 = displayInvoice?.invoice;
+  if (displayInvoice === void 0 || typeof bolt11 !== "string") {
+    const deferred = {
+      [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.reference]: snapshot.reference,
+      ...sharedElementAttributes(options),
+      ...createModeAttributes(options)
+    };
+    if (snapshot.amount_msats !== void 0) {
+      deferred[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.amountMsats] = String(snapshot.amount_msats);
+    }
+    return deferred;
+  }
+  const invoice = displayInvoice;
+  assertDisplayInvoice(bolt11);
+  const attributes = {
+    [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.reference]: snapshot.reference,
+    [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.invoiceId]: invoice.invoice_id,
+    [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.invoice]: bolt11,
+    [OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.rail]: invoice.rail
+  };
+  if (invoice.payment_hash !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.paymentHash] = invoice.payment_hash;
+  }
+  const amountMsats = invoice.amount_msats ?? snapshot.amount_msats;
+  if (amountMsats !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.amountMsats] = String(amountMsats);
+  }
+  const fiat = invoice.fiat_quote?.fiat ?? snapshot.fiat;
+  if (fiat?.currency !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.fiatCurrency] = fiat.currency;
+  }
+  if (fiat?.value !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.fiatValue] = fiat.value;
+  }
+  attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.status] = isPaidCheckoutSnapshot(snapshot) ? "settled" : snapshot.status === "expired" ? "expired" : deriveStatus(invoice);
+  if (invoice.expires_at !== void 0) {
+    attributes[OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES.expiresAt] = String(invoice.expires_at);
+  }
+  return { ...attributes, ...sharedElementAttributes(options) };
+}
+function createThemeToggleElementAttributes(options = {}) {
+  return {
+    ...options.rootSelector === void 0 ? {} : { [OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES.rootSelector]: options.rootSelector },
+    ...options.checkoutSelector === void 0 ? {} : {
+      [OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES.checkoutSelector]: options.checkoutSelector
+    },
+    ...options.defaultTheme === void 0 ? {} : { [OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES.defaultTheme]: options.defaultTheme },
+    ...options.storageKey === void 0 ? {} : { [OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES.storageKey]: options.storageKey }
+  };
+}
+function createCheckoutElementListeners(handlers = {}) {
+  return {
+    ...handlers.onCopy === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.copy]: handlers.onCopy },
+    ...handlers.onOpenWallet === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.openWallet]: handlers.onOpenWallet },
+    ...handlers.onState === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.state]: handlers.onState },
+    ...handlers.onSettled === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.settled]: handlers.onSettled },
+    ...handlers.onProviderCopy === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.providerCopy]: handlers.onProviderCopy },
+    ...handlers.onStartOver === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.startOver]: handlers.onStartOver },
+    ...handlers.onError === void 0 ? {} : { [OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS.error]: handlers.onError }
+  };
+}
+function createCheckoutShellModel(snapshot, options = {}) {
+  const theme = createStoredThemeModel(options);
+  const ownTheme = options.themeToggle !== false;
+  return {
+    theme,
+    rootAttributes: ownTheme ? theme.attributes : {},
+    checkout: {
+      tagName: OPENRECEIVE_CHECKOUT_ELEMENT_TAG_NAME,
+      attributes: createCheckoutElementAttributes(snapshot, {
+        ...options,
+        ...ownTheme ? { theme: theme.resolvedTheme } : {}
+      }),
+      listeners: createCheckoutElementListeners(options)
+    },
+    themeToggle: ownTheme ? {
+      tagName: OPENRECEIVE_THEME_TOGGLE_ELEMENT_TAG_NAME,
+      attributes: createThemeToggleElementAttributes({
+        rootSelector: options.rootSelector,
+        checkoutSelector: options.checkoutSelector ?? OPENRECEIVE_CHECKOUT_ELEMENT_TAG_NAME,
+        defaultTheme: options.defaultTheme,
+        storageKey: options.storageKey
+      })
+    } : null
+  };
+}
+function applyCheckoutElementAttributes(target, attributes) {
+  for (const [name, value] of Object.entries(attributes)) {
+    if (value !== void 0 && value !== null) target.setAttribute(name, value);
+  }
+}
+function applyCheckoutElementListeners(target, listeners) {
+  for (const [name, listener] of Object.entries(listeners)) {
+    if (listener !== void 0) target.addEventListener(name, listener);
+  }
+}
+function applyThemeToggleElementAttributes(target, attributes) {
+  for (const [name, value] of Object.entries(attributes)) {
+    if (value !== void 0) target.setAttribute(name, value);
+  }
+}
+function createThemeToggleElement(options = {}) {
+  const ownerDocument = options.document ?? globalThis.document;
+  if (ownerDocument === void 0) {
+    throw new Error("OpenReceive theme toggle element creation requires document.");
+  }
+  const element = ownerDocument.createElement(OPENRECEIVE_THEME_TOGGLE_ELEMENT_TAG_NAME);
+  applyThemeToggleElementAttributes(element, createThemeToggleElementAttributes(options));
+  return element;
+}
+function createCheckoutShell(snapshot, options = {}) {
+  const ownerDocument = options.document ?? globalThis.document;
+  if (ownerDocument === void 0) {
+    throw new Error("OpenReceive checkout shell creation requires document.");
+  }
+  const shell = createCheckoutShellModel(snapshot, options);
+  if (shell.themeToggle !== null) {
+    applyThemeAttributes(options.root, shell.theme);
+  }
+  const checkout = ownerDocument.createElement(shell.checkout.tagName);
+  applyCheckoutElementAttributes(checkout, shell.checkout.attributes);
+  applyCheckoutElementListeners(checkout, shell.checkout.listeners);
+  let themeToggle = null;
+  if (shell.themeToggle !== null) {
+    themeToggle = ownerDocument.createElement(shell.themeToggle.tagName);
+    applyThemeToggleElementAttributes(themeToggle, shell.themeToggle.attributes);
+  }
+  return {
+    theme: shell.theme,
+    rootAttributes: shell.rootAttributes,
+    checkout,
+    themeToggle
+  };
+}
+export {
+  BrowserRequestError,
+  OPENRECEIVE_CHECKOUT_DATA_ATTRIBUTES,
+  OPENRECEIVE_CHECKOUT_DATA_SELECTORS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_ATTRIBUTES,
+  OPENRECEIVE_CHECKOUT_ELEMENT_EVENTS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_PARTS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_PART_SELECTORS,
+  OPENRECEIVE_CHECKOUT_ELEMENT_TAG_NAME,
+  OPENRECEIVE_COPY_FEEDBACK_MS,
+  OPENRECEIVE_DEFAULT_POLL_INTERVAL_MS,
+  OPENRECEIVE_DEFAULT_PREFIX,
+  OPENRECEIVE_PAYMENT_WIZARD_ATTRIBUTES,
+  OPENRECEIVE_PAYMENT_WIZARD_SELECTORS,
+  OPENRECEIVE_THEME_STORAGE_KEY,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_ATTRIBUTES,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_EVENTS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_PARTS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_PART_SELECTORS,
+  OPENRECEIVE_THEME_TOGGLE_ELEMENT_TAG_NAME,
+  applyCheckoutElementAttributes,
+  assertDisplayInvoice,
+  assetButtonClasses,
+  buildMethodGridEntries,
+  checkoutElementStyles,
+  checkoutLabels,
+  copyInvoice,
+  createBlockExplorerUrl,
+  createCheckoutActionEvent,
+  createCheckoutController,
+  createCheckoutElementAttributes,
+  createCheckoutElementListeners,
+  createCheckoutErrorEvent,
+  createCheckoutProviderCopyEvent,
+  createCheckoutSession,
+  createCheckoutShell,
+  createCheckoutShellModel,
+  createCheckoutSnapshotFromInvoice,
+  createCheckoutState,
+  createCheckoutStateEvent,
+  createCheckoutStatusModel,
+  createDetailExternalLink,
+  createLightningInvoiceDecodeUrl,
+  createPaymentDataEntries,
+  createPaymentWizardController,
+  createPaymentWizardModel,
+  createPaymentWizardSelection,
+  createQrPayloadSvg,
+  createQrSvg,
+  createStatusFetcher,
+  createStoredThemeModel,
+  createSwapDisplayModel,
+  createSwapUnavailableModel,
+  createThemeChangeEvent,
+  createThemeModel,
+  createThemeToggleElement,
+  createThemeToggleElementAttributes,
+  createTickingValueController,
+  createTransactionDetails,
+  createTransactionDetailsFromState,
+  createTransientFeedbackController,
+  createWizardRouteAssetDisplays,
+  createWizardRouteDisplays,
+  deriveCheckoutStateLabels,
+  deriveStatus,
+  enterCheckoutResumePath,
+  escapeHtml,
+  findSwapGridGroup,
+  formatAmountCaption,
+  formatChooseNetworkHeading,
+  formatDepositAmount,
+  formatFiatAmount,
+  formatMsats,
+  formatNetworkSummary,
+  formatSwapLimit,
+  formatUnixTime,
+  getExplorerNetwork,
+  getNetworkIcon,
+  getPaymentMethodIcon,
+  getRouteNetworkLabel,
+  getSwapOptionIcon,
+  getSwapRefundFormError,
+  getWizardEmptyMessage,
+  isReusableLightningInvoice,
+  mergeAttemptIntoCheckout,
+  mergeAttemptIntoSnapshot,
+  networkButtonClasses,
+  networkCheckClasses,
+  networkMobileRevealClasses,
+  networkSummaryIconClasses,
+  normalizeSwapStartInvoice,
+  openWallet,
+  orClasses,
+  overlaySwapRefundStaging,
+  parseBooleanAttribute,
+  parseMethodPickerKey,
+  parseOptionalInteger,
+  parsePaymentMethod,
+  parseResolvedTheme,
+  parseThemePreference,
+  paymentAccentId,
+  paymentIconUrls,
+  paymentMethods,
+  postJson,
+  prepareCheckout,
+  readThemePreference,
+  requestCheckout,
+  requestSwapRefund,
+  resolvePreservedNetworkSelection,
+  resolveTransactionDetailRows,
+  selectCheckoutDisplayInvoice,
+  startSwapRequest,
+  swapAssetMatchesRoute,
+  swapGroupLimitOption,
+  swapOptionLimitMessage,
+  swapPickerKey,
+  syncStoredThemeControls,
+  toggleStoredThemeControls,
+  updatePaymentWizardSelection,
+  updateSelectedSwapNetworks,
+  validateCheckoutProps,
+  wizardNetworkGroupIds,
+  writeThemePreference
+};