@tuppence/js 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1304 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/appearance.ts
+function appearanceFor(branding) {
+  const accent = branding?.accent_color ?? TUPPENCE_BLUE;
+  return {
+    theme: "stripe",
+    variables: {
+      colorPrimary: accent,
+      colorText: "#1f2937",
+      colorDanger: "#b42318",
+      fontFamily: '"Inter", system-ui, -apple-system, sans-serif',
+      fontSizeBase: "16px",
+      borderRadius: "8px",
+      spacingUnit: "4px"
+    },
+    rules: {
+      ".Input:focus": { borderColor: accent, boxShadow: `0 0 0 2px ${accent}33` }
+    }
+  };
+}
+var TUPPENCE_BLUE;
+var init_appearance = __esm({
+  "src/appearance.ts"() {
+    "use strict";
+    TUPPENCE_BLUE = "#3b5bff";
+  }
+});
+
+// src/errors.ts
+var TuppenceError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    TuppenceError = class _TuppenceError extends Error {
+      constructor(fields) {
+        super(fields.message);
+        this.name = "TuppenceError";
+        this.type = fields.type;
+        this.code = fields.code ?? null;
+        this.declineCode = fields.declineCode ?? null;
+        this.param = fields.param ?? null;
+        this.status = fields.status ?? 0;
+      }
+      /** The API's envelope: `{ error: { type, code, message, param, decline_code } }`. */
+      static fromEnvelope(status, body) {
+        const error = body?.error ?? {};
+        const text = (key) => typeof error[key] === "string" ? String(error[key]) : null;
+        return new _TuppenceError({
+          type: text("type") ?? "api_error",
+          message: text("message") ?? `Tuppence answered ${status}.`,
+          code: text("code"),
+          declineCode: text("decline_code"),
+          param: text("param"),
+          status
+        });
+      }
+      /** Stripe.js's error (card fields, a confirmation token, a bank's check). */
+      static fromStripe(error) {
+        return new _TuppenceError({
+          type: error.type ?? "api_error",
+          message: error.message ?? "Stripe could not take the card.",
+          code: error.code ?? null,
+          declineCode: error.decline_code ?? null,
+          param: error.param ?? null
+        });
+      }
+    };
+  }
+});
+
+// src/express-mount.ts
+var express_mount_exports = {};
+__export(express_mount_exports, {
+  Wallet: () => Wallet,
+  asCartAddress: () => asCartAddress,
+  cartAddressOf: () => cartAddressOf,
+  mountAddress: () => mountAddress
+});
+function cartAddressOf(address) {
+  const region = address.state?.trim().toUpperCase() ?? "";
+  const postcode = address.postal_code?.trim() ?? "";
+  return {
+    country: (address.country ?? "").trim().toUpperCase(),
+    region: /^[A-Z0-9]{1,3}$/.test(region) ? region : null,
+    postcode: postcode && postcode.length <= 12 ? postcode : null
+  };
+}
+function daysTo(date, today) {
+  const from = Date.UTC(today.getFullYear(), today.getMonth(), today.getDate());
+  return Math.max(0, Math.round((Date.parse(`${date}T00:00:00Z`) - from) / DAY_MS));
+}
+async function mountAddress(host, tuppence, from, options, target) {
+  const elements = "create" in from ? from : await tuppence.elements(from, {
+    appearance: options.appearance ?? appearanceFor(from.branding)
+  });
+  if (host.destroyed()) return;
+  if (!elements) return host.emit("error", noStripe("Stripe address field"));
+  const { mode, defaultValues, allowedCountries, phone } = options;
+  const element = elements.create("address", {
+    mode,
+    autocomplete: { mode: "automatic" },
+    ...defaultValues ? { defaultValues } : {},
+    ...allowedCountries ? { allowedCountries } : {},
+    ...phone ? { fields: { phone } } : {}
+  });
+  host.attach(element);
+  element.on("ready", () => host.emit("ready", void 0));
+  element.on(
+    "change",
+    (event) => host.emit("change", {
+      complete: event.complete,
+      empty: event.empty,
+      value: event.value,
+      address: asCartAddress(event.value)
+    })
+  );
+  element.on("loaderror", (event) => host.emit("error", TuppenceError.fromStripe(event.error)));
+  element.mount(target);
+}
+var QUOTE_TIMEOUT_MS, DAY_MS, asCartAddress, Wallet, noDelivery;
+var init_express_mount = __esm({
+  "src/express-mount.ts"() {
+    "use strict";
+    init_appearance();
+    init_errors();
+    init_express();
+    QUOTE_TIMEOUT_MS = 15e3;
+    DAY_MS = 864e5;
+    asCartAddress = (value) => value?.address?.country ? cartAddressOf(value.address) : null;
+    Wallet = class {
+      constructor(host, tuppence, payable, options, cart) {
+        this.host = host;
+        this.tuppence = tuppence;
+        this.payable = payable;
+        this.options = options;
+        this.cart = cart;
+        this.address = null;
+        this.delivery = null;
+        this.elements = null;
+        this.basket = options.basket ?? null;
+        this.amount = payable.amount;
+      }
+      /** The delivery choices as the sheet lists them: the chosen one first, as Stripe selects it. */
+      ratesOf(basket) {
+        const today = this.options.now?.() ?? /* @__PURE__ */ new Date();
+        const options = [...basket?.delivery_options ?? []].sort(
+          (a, b) => Number(b.selected) - Number(a.selected)
+        );
+        return options.map((o) => ({
+          id: o.key,
+          displayName: o.name,
+          amount: o.amount,
+          deliveryEstimate: {
+            minimum: { unit: "day", value: daysTo(o.earliest, today) },
+            maximum: { unit: "day", value: daysTo(o.latest, today) }
+          }
+        }));
+      }
+      /** A quote, or why there is none: refused after 15 s rather than left to hang the sheet. */
+      async within(ask) {
+        let timer;
+        const late = new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(
+              new TuppenceError({
+                type: "api_connection_error",
+                code: "quote_timeout",
+                message: "The delivery prices took too long to come back. Try again."
+              })
+            ),
+            QUOTE_TIMEOUT_MS
+          );
+        });
+        try {
+          return await Promise.race([ask(), late]);
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      /** The quote's answer for the sheet, or the reason it can't be delivered. */
+      deliverable(basket) {
+        if (!basket.totals || basket.delivery_options.length === 0) {
+          throw new TuppenceError({
+            type: "invalid_request_error",
+            code: basket.delivery_refusal?.code ?? "no_delivery_options",
+            message: basket.delivery_refusal?.message ?? "This basket can't be delivered there."
+          });
+        }
+        return basket;
+      }
+      priced(basket) {
+        this.basket = basket;
+        this.delivery = basket.delivery_options.find((o) => o.selected)?.key ?? null;
+        this.amount = basket.totals?.due ?? this.amount;
+        this.elements?.update({ amount: this.amount });
+        this.host.emit("total", basket);
+      }
+      async addressChanged(event) {
+        const address = cartAddressOf(event.address);
+        const delivery = this.delivery;
+        try {
+          const ask = this.options.onShippingAddressChange ?? (() => this.cart.quote({ address, delivery }));
+          const basket = this.deliverable(
+            await this.within(() => ask({ name: event.name, address, delivery }))
+          );
+          if (this.host.destroyed()) return;
+          this.address = address;
+          this.priced(basket);
+          event.resolve({ shippingRates: this.ratesOf(basket) });
+        } catch (caught) {
+          event.reject();
+          this.host.emit("error", wrap(caught));
+        }
+      }
+      async rateChanged(event) {
+        const delivery = event.shippingRate.id;
+        const address = this.address;
+        try {
+          const ask = this.options.onShippingRateChange ?? (() => this.cart.quote({ address, delivery }));
+          const basket = this.deliverable(await this.within(() => ask({ delivery, address })));
+          if (this.host.destroyed()) return;
+          if (!basket.delivery_options.some((o) => o.key === delivery && o.selected)) {
+            throw new TuppenceError({
+              type: "invalid_request_error",
+              code: "delivery_unavailable",
+              message: "That delivery choice isn't available any more. Choose another."
+            });
+          }
+          this.priced(basket);
+          event.resolve();
+        } catch (caught) {
+          event.reject();
+          this.host.emit("error", wrap(caught));
+        }
+      }
+      async confirmed(event) {
+        const elements = this.elements;
+        if (!elements) return;
+        const failed = (error) => {
+          event.paymentFailed({ reason: "fail", message: error.message });
+          this.host.emit("error", error);
+        };
+        const token = await this.tuppence.confirmationToken(elements);
+        if ("error" in token) return failed(token.error);
+        try {
+          const outcome = await this.options.onConfirm({
+            confirmationToken: token.id,
+            amount: this.amount,
+            delivery: event.shippingRate?.id ?? (this.options.shipping === false ? null : this.delivery),
+            email: event.billingDetails?.email ?? null,
+            phone: event.billingDetails?.phone ?? null,
+            shippingAddress: event.shippingAddress ?? null,
+            billingDetails: event.billingDetails ?? null,
+            expressPaymentType: event.expressPaymentType,
+            basket: this.basket
+          });
+          const refusal = outcome?.error;
+          if (refusal) {
+            failed(
+              new TuppenceError({
+                type: "api_error",
+                message: typeof refusal.message === "string" ? refusal.message : "The payment didn't go through."
+              })
+            );
+          }
+        } catch (caught) {
+          failed(wrap(caught));
+        }
+      }
+      async load(target) {
+        const shipping = this.options.shipping !== false;
+        const [elements, basket] = await Promise.all([
+          this.tuppence.elements(this.payable, {
+            appearance: this.options.appearance ?? appearanceFor(this.payable.branding)
+          }),
+          this.basket || !shipping ? this.basket : this.cart.get()
+        ]);
+        if (this.host.destroyed()) return;
+        if (!elements) return this.host.emit("error", noStripe("wallet"));
+        this.elements = elements;
+        this.basket = basket;
+        this.delivery = basket?.delivery_options.find((o) => o.selected)?.key ?? null;
+        const name = this.payable.branding?.display_name;
+        const element = elements.create("expressCheckout", {
+          ...this.options.buttons,
+          emailRequired: true,
+          phoneNumberRequired: this.options.phone === true,
+          shippingAddressRequired: shipping,
+          ...this.options.allowedShippingCountries ? { allowedShippingCountries: this.options.allowedShippingCountries } : {},
+          ...name ? { business: { name } } : {}
+        });
+        this.host.attach(element);
+        element.on(
+          "ready",
+          (event) => this.host.emit(
+            "ready",
+            Object.entries(event.availablePaymentMethods ?? {}).filter(([, on]) => on).map(([method]) => method)
+          )
+        );
+        element.on(
+          "loaderror",
+          (event) => this.host.emit("error", TuppenceError.fromStripe(event.error))
+        );
+        element.on("click", (event) => {
+          const rates = this.ratesOf(this.basket);
+          if (shipping && rates.length === 0) {
+            event.reject();
+            return this.host.emit("error", noDelivery(this.basket));
+          }
+          event.resolve(shipping ? { shippingRates: rates } : {});
+        });
+        element.on("shippingaddresschange", (event) => void this.addressChanged(event));
+        element.on("shippingratechange", (event) => void this.rateChanged(event));
+        element.on("cancel", () => {
+          this.amount = this.payable.amount;
+          this.address = null;
+          elements.update({ amount: this.amount });
+          this.host.emit("cancel", void 0);
+        });
+        element.on("confirm", (event) => void this.confirmed(event));
+        element.mount(target);
+      }
+    };
+    noDelivery = (basket) => new TuppenceError({
+      type: "invalid_request_error",
+      code: basket?.delivery_refusal?.code ?? "no_delivery_options",
+      message: basket?.delivery_refusal?.message ?? "This basket has no delivery options yet."
+    });
+  }
+});
+
+// src/express.ts
+var mounting, wrap, noStripe, Mountable, ExpressCheckout, AddressField;
+var init_express = __esm({
+  "src/express.ts"() {
+    "use strict";
+    init_errors();
+    mounting = () => Promise.resolve().then(() => (init_express_mount(), express_mount_exports));
+    wrap = (caught) => caught instanceof TuppenceError ? caught : new TuppenceError({ type: "api_error", message: String(caught) });
+    noStripe = (what) => new TuppenceError({
+      type: "invalid_request_error",
+      code: "no_card_fields",
+      message: `There is no ${what} here: this environment runs the simulated gateway.`
+    });
+    Mountable = class {
+      constructor() {
+        this.handlers = {};
+        this.mounted = null;
+        this.destroyed = false;
+        this.element = null;
+      }
+      on(event, handler) {
+        const list = this.handlers[event] ?? [];
+        list.push(handler);
+        this.handlers[event] = list;
+        return this;
+      }
+      /** Shows it in `target` (an element, or a selector). Loads Stripe.js if it must. */
+      mount(target) {
+        this.destroyed = false;
+        this.mounted ?? (this.mounted = this.load(target).catch(
+          (caught) => this.emit("error", wrap(caught))
+        ));
+        return this;
+      }
+      /** Takes it off the page (or keeps it off, while it loads) and says nothing more. */
+      destroy() {
+        this.destroyed = true;
+        this.mounted = null;
+        this.element?.destroy();
+        this.element = null;
+      }
+      emit(event, detail) {
+        if (this.destroyed) return;
+        for (const handler of this.handlers[event] ?? []) handler(detail);
+      }
+      /** What the mounted half (`./express-mount.js`) may do to this. */
+      host() {
+        return {
+          emit: (event, detail) => this.emit(event, detail),
+          destroyed: () => this.destroyed,
+          attach: (element) => {
+            this.element = element;
+          }
+        };
+      }
+    };
+    ExpressCheckout = class extends Mountable {
+      constructor(tuppence, payable, options, cart) {
+        super();
+        this.tuppence = tuppence;
+        this.payable = payable;
+        this.options = options;
+        this.cart = cart;
+        this.wallet = null;
+      }
+      async load(target) {
+        const { Wallet: Wallet2 } = await mounting();
+        if (this.destroyed) return;
+        this.wallet ?? (this.wallet = new Wallet2(this.host(), this.tuppence, this.payable, this.options, this.cart));
+        await this.wallet.load(target);
+      }
+    };
+    AddressField = class extends Mountable {
+      constructor(tuppence, from, options) {
+        super();
+        this.tuppence = tuppence;
+        this.from = from;
+        this.options = options;
+      }
+      /** The address, checked: Stripe shows what is missing beside its field. */
+      async value() {
+        await this.mounted;
+        const element = this.element;
+        if (!element) throw new TypeError("Mount the address, and let it load, before reading it.");
+        const [{ complete, value }, { asCartAddress: asCartAddress2 }] = await Promise.all([
+          element.getValue(),
+          mounting()
+        ]);
+        return { complete, value, address: asCartAddress2(value) };
+      }
+      async load(target) {
+        const { mountAddress: mountAddress2 } = await mounting();
+        if (this.destroyed) return;
+        await mountAddress2(this.host(), this.tuppence, this.from, this.options, target);
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StorefrontCartClient: () => StorefrontCartClient,
+  Tuppence: () => Tuppence,
+  TuppenceError: () => TuppenceError,
+  appearanceFor: () => appearanceFor,
+  createTuppence: () => createTuppence,
+  loadTuppence: () => loadTuppence,
+  stripeLocale: () => stripeLocale
+});
+module.exports = __toCommonJS(index_exports);
+init_appearance();
+init_errors();
+
+// src/locale.ts
+var STRIPE_LOCALES = /* @__PURE__ */ new Set([
+  "ar",
+  "bg",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "en",
+  "en-AU",
+  "en-CA",
+  "en-NZ",
+  "en-GB",
+  "es",
+  "es-ES",
+  "es-419",
+  "et",
+  "fi",
+  "fil",
+  "fr",
+  "fr-CA",
+  "fr-FR",
+  "he",
+  "hu",
+  "hr",
+  "id",
+  "it",
+  "it-IT",
+  "ja",
+  "ko",
+  "lt",
+  "lv",
+  "ms",
+  "mt",
+  "nb",
+  "nl",
+  "no",
+  "pl",
+  "pt",
+  "pt-BR",
+  "ro",
+  "ru",
+  "sk",
+  "sl",
+  "sv",
+  "th",
+  "tr",
+  "vi",
+  "zh",
+  "zh-HK",
+  "zh-TW"
+]);
+function stripeLocale(tag) {
+  const parts = (tag ?? "").trim().replace(/_/g, "-").split("-").filter(Boolean);
+  const language = parts[0]?.toLowerCase();
+  if (!language || !/^[a-z]{2,3}$/.test(language)) return "auto";
+  const region = parts.slice(1).find((p) => /^([A-Za-z]{2}|\d{3})$/.test(p));
+  const variant = region ? `${language}-${region.toUpperCase()}` : null;
+  if (language === "pt") return variant === "pt-BR" ? "pt-BR" : "en";
+  if (variant && STRIPE_LOCALES.has(variant)) return variant;
+  return STRIPE_LOCALES.has(language) ? language : "en";
+}
+function browserLanguage() {
+  const nav = globalThis.navigator;
+  return typeof nav?.language === "string" && nav.language ? nav.language : void 0;
+}
+
+// src/http.ts
+init_errors();
+var READ_RETRIES = 2;
+var RETRY_BASE_MS = 250;
+var RETRY_MAX_MS = 2e3;
+var TRANSIENT = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var Http = class {
+  constructor(base, fetchImpl, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), credentials = "omit") {
+    this.base = base;
+    this.fetchImpl = fetchImpl;
+    this.sleep = sleep;
+    this.credentials = credentials;
+  }
+  get(path, headers) {
+    return this.request("GET", path, headers);
+  }
+  post(path, headers, body) {
+    return this.request("POST", path, headers, body);
+  }
+  async request(method, path, headers, body) {
+    const retries = method === "GET" ? READ_RETRIES : 0;
+    for (let attempt = 0; ; attempt += 1) {
+      const wait = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** attempt);
+      let response;
+      try {
+        response = await this.fetchImpl(`${this.base}${path}`, {
+          method,
+          credentials: this.credentials,
+          headers: {
+            Accept: "application/json",
+            ...body === void 0 ? {} : { "Content-Type": "application/json" },
+            ...headers
+          },
+          ...body === void 0 ? {} : { body: JSON.stringify(body) }
+        });
+      } catch {
+        if (attempt < retries) {
+          await this.sleep(wait);
+          continue;
+        }
+        throw new TuppenceError({
+          type: "api_connection_error",
+          message: "Tuppence could not be reached. Check the connection and try again."
+        });
+      }
+      const json = await response.json().catch(() => null);
+      if (response.ok) return json;
+      if (attempt < retries && TRANSIENT.has(response.status)) {
+        const after = Number(response.headers.get("retry-after"));
+        await this.sleep(after > 0 ? Math.min(after * 1e3, RETRY_MAX_MS) : wait);
+        continue;
+      }
+      throw TuppenceError.fromEnvelope(response.status, json);
+    }
+  }
+};
+
+// src/storefront.ts
+var StorefrontCartClient = class {
+  constructor(fetchImpl, options = {}) {
+    const base = (options.base ?? "").replace(/\/+$/, "");
+    const headless = /^https?:\/\//.test(base);
+    this.http = new Http(base, fetchImpl, void 0, headless ? "omit" : "same-origin");
+    this.headers = {
+      ...options.publishableKey ? { "Tuppence-Publishable-Key": options.publishableKey } : {},
+      ...options.cartToken ? { "Tuppence-Cart": options.cartToken } : {}
+    };
+  }
+  /** The shopper's basket on this store, priced. */
+  get() {
+    return this.http.get("/storefront/v1/cart", this.headers);
+  }
+  /** The totals for an address and a delivery choice, changing nothing. */
+  quote(input) {
+    return this.http.post("/storefront/v1/cart/quote", this.headers, {
+      address: input.address ?? null,
+      delivery: input.delivery ?? null
+    });
+  }
+};
+
+// src/bank-details.ts
+init_errors();
+var invalid = (message, param) => new TuppenceError({ type: "invalid_request_error", code: "parameter_invalid", message, param });
+var IBAN_LENGTHS = {
+  AT: 20,
+  BE: 16,
+  CY: 28,
+  DE: 22,
+  EE: 20,
+  ES: 24,
+  FI: 18,
+  FR: 27,
+  GR: 27,
+  HR: 21,
+  IE: 22,
+  IT: 27,
+  LT: 20,
+  LU: 20,
+  LV: 21,
+  MT: 31,
+  NL: 18,
+  PT: 25,
+  SI: 19,
+  SK: 24
+};
+function mod97(iban) {
+  let remainder = 0;
+  for (const ch of `${iban.slice(4)}${iban.slice(0, 4)}`) {
+    for (const digit of String(Number.parseInt(ch, 36))) {
+      remainder = (remainder * 10 + Number(digit)) % 97;
+    }
+  }
+  return remainder === 1;
+}
+function ibanError(iban, country, length) {
+  if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(iban) || !iban.startsWith(country)) {
+    return invalid("Enter the IBAN: it starts with the bank's country code.", "account_number");
+  }
+  if (iban.length !== length) {
+    return invalid(`Check the IBAN: it is ${length} characters in this country.`, "account_number");
+  }
+  if (!mod97(iban)) {
+    return invalid("Check the IBAN: a character is wrong.", "account_number");
+  }
+  return null;
+}
+function externalAccountParams(details) {
+  const country = details.country.toUpperCase();
+  const routing = (details.routingNumber ?? "").replace(/[\s-]/g, "");
+  const account = details.accountNumber.replace(/[\s-]/g, "").toUpperCase();
+  const holder = details.accountHolderName.trim();
+  const ibanLength = IBAN_LENGTHS[country];
+  if (country !== "GB" && country !== "US" && !ibanLength) {
+    return {
+      error: invalid("Bank accounts can be added in GB, the US or the eurozone.", "country")
+    };
+  }
+  if (!holder) return { error: invalid("Enter the name on the account.", "account_holder_name") };
+  if (ibanLength) {
+    if (routing) {
+      return {
+        error: invalid(
+          "For this country, the IBAN is the whole bank account: leave the routing number out.",
+          "routing_number"
+        )
+      };
+    }
+    const error = ibanError(account, country, ibanLength);
+    if (error) return { error };
+    return {
+      externalAccount: {
+        object: "bank_account",
+        country,
+        currency: details.currency.toLowerCase(),
+        account_holder_name: holder,
+        account_holder_type: details.accountHolderType,
+        account_number: account
+      }
+    };
+  }
+  if (country === "GB") {
+    if (!/^\d{6}$/.test(routing)) {
+      return { error: invalid("A sort code is 6 digits, like 10-88-00.", "routing_number") };
+    }
+    if (!/^\d{8}$/.test(account)) {
+      return { error: invalid("A UK account number is 8 digits.", "account_number") };
+    }
+  } else {
+    if (!/^\d{9}$/.test(routing)) {
+      return { error: invalid("A routing number is 9 digits.", "routing_number") };
+    }
+    if (!/^\d{4,17}$/.test(account)) {
+      return { error: invalid("Check the account number: 4 to 17 digits.", "account_number") };
+    }
+  }
+  return {
+    externalAccount: {
+      object: "bank_account",
+      country,
+      currency: details.currency.toLowerCase(),
+      account_holder_name: holder,
+      account_holder_type: details.accountHolderType,
+      routing_number: routing,
+      account_number: account
+    }
+  };
+}
+
+// src/tuppence.ts
+init_errors();
+init_express();
+
+// src/sheet.ts
+init_appearance();
+init_errors();
+var simulated = () => new TuppenceError({
+  type: "invalid_request_error",
+  code: "no_card_fields",
+  message: "There are no card fields here: this environment runs the simulated gateway. Pay with `testPaymentMethod` instead."
+});
+var Sheet = class {
+  constructor(tuppence, options) {
+    this.tuppence = tuppence;
+    this.options = options;
+    this.handlers = {
+      ready: [],
+      change: [],
+      error: []
+    };
+    this.mounted = null;
+    /** Taken down: a load still under way never mounts, and nothing is told any more. */
+    this.destroyed = false;
+  }
+  on(event, handler) {
+    this.handlers[event].push(handler);
+    return this;
+  }
+  /** Shows the fields in `target` (an element, or a selector). Loads Stripe.js if it must. */
+  mount(target) {
+    this.destroyed = false;
+    this.mounted ?? (this.mounted = this.load(target).catch((caught) => {
+      this.emit(
+        "error",
+        caught instanceof TuppenceError ? caught : new TuppenceError({ type: "api_error", message: String(caught) })
+      );
+      return null;
+    }));
+    return this;
+  }
+  /**
+   * Takes the fields off the page — or, while they are still loading, keeps them off it — and
+   * says nothing more. The sheet can be mounted again.
+   */
+  destroy() {
+    this.destroyed = true;
+    const mounted = this.mounted;
+    this.mounted = null;
+    void mounted?.then((m) => m?.element.destroy());
+  }
+  emit(event, ...detail) {
+    if (this.destroyed) return;
+    for (const handler of this.handlers[event]) handler(...detail);
+  }
+  async ready() {
+    const mounted = await this.mounted;
+    if (!mounted) {
+      throw new TypeError("Mount the sheet, and let its fields load, before confirming.");
+    }
+    return mounted;
+  }
+  async load(target) {
+    const elements = await this.elementsFor();
+    if (this.destroyed) return null;
+    if (!elements) {
+      this.emit("error", simulated());
+      return null;
+    }
+    const wallet = this.options.wallets ?? "auto";
+    const element = elements.create("payment", {
+      layout: this.options.layout ?? "tabs",
+      wallets: { applePay: wallet, googlePay: wallet }
+    });
+    element.on("ready", () => this.emit("ready"));
+    element.on(
+      "change",
+      (event) => this.emit("change", { complete: event.complete, empty: event.empty })
+    );
+    element.on("loaderror", (event) => this.emit("error", TuppenceError.fromStripe(event.error)));
+    element.mount(target);
+    return { elements, element };
+  }
+};
+var PaymentSheet = class extends Sheet {
+  constructor(tuppence, paymentOptions) {
+    super(tuppence, paymentOptions);
+    this.paymentOptions = paymentOptions;
+    this.amount = paymentOptions.amount;
+  }
+  async elementsFor() {
+    const payment = this.paymentOptions.payment ?? await this.tuppence.retrievePayment(this.paymentOptions.clientSecret);
+    return this.tuppence.elements(payment, {
+      appearance: this.paymentOptions.appearance ?? appearanceFor(payment.branding),
+      ...this.paymentOptions.locale ? { locale: this.paymentOptions.locale } : {},
+      ...this.amount === void 0 ? {} : { amount: this.amount }
+    });
+  }
+  /** What is charged changed (a tip): the fields — and Apple Pay's sheet — show the new total. */
+  setAmount(amount) {
+    this.amount = amount;
+    void this.mounted?.then((m) => m?.elements.update({ amount }));
+  }
+  /** Pays: the steps of `confirmPayment`, with the fields this sheet shows. */
+  async confirm(options = {}) {
+    const { elements } = await this.ready();
+    return this.tuppence.confirmPayment({
+      clientSecret: this.paymentOptions.clientSecret,
+      elements,
+      ...options.tipAmount === void 0 ? {} : { tipAmount: options.tipAmount },
+      ...options.params ? { params: options.params } : {}
+    });
+  }
+};
+var SetupSheet = class extends Sheet {
+  constructor(tuppence, setupOptions) {
+    super(tuppence, setupOptions);
+    this.setupOptions = setupOptions;
+  }
+  async elementsFor() {
+    const session = this.setupOptions.setupSession ?? await this.tuppence.retrieveSetupSession(this.setupOptions.clientSecret);
+    return this.tuppence.setupElements(session, {
+      appearance: this.setupOptions.appearance ?? appearanceFor(session.branding),
+      ...this.setupOptions.locale ? { locale: this.setupOptions.locale } : {}
+    });
+  }
+  async confirm(options = {}) {
+    const { elements } = await this.ready();
+    return this.tuppence.confirmSetup({
+      clientSecret: this.setupOptions.clientSecret,
+      elements,
+      ...options.params ? { params: options.params } : {}
+    });
+  }
+};
+
+// src/tuppence.ts
+var DEFAULT_API = "https://api.tuppence.ai";
+var PUBLISHABLE_KEY_HEADER = "Tuppence-Publishable-Key";
+var CLIENT_SECRET_HEADER = "Tuppence-Client-Secret";
+var WAITING = /* @__PURE__ */ new Set(["requires_action", "processing"]);
+var stillWaiting = (current) => WAITING.has(current.status) && !(current.status === "processing" && typeof current.payment_method_type === "string" && current.payment_method_type !== "card");
+var TOPUP_PAGE = /^\/card-topup\/[A-Za-z0-9]{20,64}\/?$/;
+var LOCAL = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function objectOf(clientSecret, prefix) {
+  const secret = typeof clientSecret === "string" ? clientSecret : "";
+  const at = secret.indexOf("_secret_");
+  const id = at > 0 ? secret.slice(0, at) : "";
+  if (!id.startsWith(prefix) || !/^[A-Za-z0-9_]+$/.test(id)) {
+    const what = prefix === "pay_" ? "a payment" : "a setup session";
+    throw new TypeError(`Expected the client secret of ${what} (${prefix}\u2026_secret_\u2026).`);
+  }
+  return id;
+}
+var secretHeader = (clientSecret) => ({ [CLIENT_SECRET_HEADER]: clientSecret });
+var refused = (last) => new TuppenceError({
+  type: "card_error",
+  message: last.message ?? "The card was declined.",
+  code: last.code,
+  declineCode: last.decline_code,
+  status: 402
+});
+var unknownOutcome = (error) => error.status === 0 || error.status === 409 || error.status >= 500;
+var Tuppence = class _Tuppence {
+  constructor(options = {}, config = null) {
+    this.config = config;
+    this.stripes = /* @__PURE__ */ new Map();
+    /** The Stripe instance each set of card fields came from: its token must come from it too. */
+    this.owners = /* @__PURE__ */ new WeakMap();
+    /**
+     * The card balance's hosted top-up page (54-18). Your server makes a link
+     * (`POST /v1/issuing/topup_links`, with your secret key) and hands its `url` to the page;
+     * `tuppence.topups.redirect({ url })` sends the person there — to top up by card or by bank
+     * transfer, in your (or your Connect platform's) branding — and they come back to the link's
+     * `return_url`. Only a Tuppence top-up page's address is followed: anything else throws.
+     */
+    this.topups = {
+      /**
+       * Stripe's card fields for a hosted top-up page's card (54-18), to charge `amount` (the
+       * card option's `total`). Null where no Stripe is behind the environment: there,
+       * `pay({ testPaymentMethod })` names one of Stripe's test cards.
+       */
+      elements: async (page, options) => {
+        const stripe = await this.stripeFor(page);
+        if (!stripe) return null;
+        const { amount, ...look } = options;
+        const elements = stripe.elements({
+          ...look,
+          mode: "payment",
+          amount,
+          currency: page.currency,
+          captureMethod: "automatic",
+          paymentMethodTypes: ["card"]
+        });
+        this.owners.set(elements, stripe);
+        return elements;
+      },
+      /**
+       * Tops up by card on a hosted top-up page (54-18): the card presented (Stripe's fields make a
+       * confirmation token), the top-up made, the bank's check in Stripe's own frame if it asks,
+       * then the page read back until the bank and Stripe have answered. `businessFunds: true` is
+       * the person's word that the card is the business's own money.
+       */
+      pay: async (options) => {
+        const path = `/public/issuing_topup_links/${encodeURIComponent(options.token)}`;
+        const presented = await this.present(
+          {
+            clientSecret: "",
+            elements: options.elements,
+            testPaymentMethod: options.testPaymentMethod
+          },
+          false
+        );
+        if ("error" in presented) {
+          return { page: await this.http.get(path, {}), error: presented.error };
+        }
+        let page = await this.http.post(
+          `${path}/topups`,
+          {},
+          {
+            ...presented.body,
+            business_funds: options.businessFunds,
+            ...options.amount === void 0 ? {} : { amount: options.amount }
+          }
+        );
+        const secret = page.topup?.status === "requires_action" ? page.topup.client_secret : null;
+        const stripe = secret ? await this.stripeFor(page) : null;
+        if (!secret || !stripe) return { page };
+        const handled = await stripe.handleNextAction({ clientSecret: secret });
+        for (let waited = 0; waited < this.timeoutMs; waited += this.intervalMs) {
+          page = await this.http.get(path, {});
+          if (page.topup?.status !== "requires_action") break;
+          await this.sleep(this.intervalMs);
+        }
+        return handled.error ? { page, error: TuppenceError.fromStripe(handled.error) } : { page };
+      },
+      /**
+       * Finishes the bank's check on a hosted page's card top-up that waited for it when the page
+       * opened (a reload half-way), in Stripe's own frame, then reads the page back.
+       */
+      resume: async (options) => {
+        const path = `/public/issuing_topup_links/${encodeURIComponent(options.token)}`;
+        let page = await this.http.get(path, {});
+        const secret = page.topup?.status === "requires_action" ? page.topup.client_secret : null;
+        const stripe = secret ? await this.stripeFor(page) : null;
+        if (!secret || !stripe) return { page };
+        const handled = await stripe.handleNextAction({ clientSecret: secret });
+        for (let waited = 0; waited < this.timeoutMs; waited += this.intervalMs) {
+          page = await this.http.get(path, {});
+          if (page.topup?.status !== "requires_action") break;
+          await this.sleep(this.intervalMs);
+        }
+        return handled.error ? { page, error: TuppenceError.fromStripe(handled.error) } : { page };
+      },
+      redirect: (options) => {
+        let target = null;
+        try {
+          target = new URL(typeof options?.url === "string" ? options.url : "");
+        } catch {
+          target = null;
+        }
+        const secure = target?.protocol === "https:" || target?.protocol === "http:" && LOCAL.has(target.hostname);
+        if (!target || !secure || !TOPUP_PAGE.test(target.pathname) || target.search || target.hash) {
+          throw new TypeError(
+            "topups.redirect takes a top-up link's `url`, as `POST /v1/issuing/topup_links` answered it (https://\u2026/card-topup/\u2026)."
+          );
+        }
+        this.navigate(target.toString());
+      }
+    };
+    const fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.fetchImpl = fetchImpl;
+    this.sleep = options.poll?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    this.navigate = options.navigate ?? ((url) => globalThis.location.assign(url));
+    this.http = new Http(
+      (options.apiBase ?? DEFAULT_API).replace(/\/+$/, ""),
+      fetchImpl,
+      this.sleep
+    );
+    this.loadStripe = options.loadStripe ?? (async (key, { stripeAccount, locale }) => {
+      const { loadStripe } = await import("@stripe/stripe-js/pure");
+      return loadStripe(key, { stripeAccount, locale });
+    });
+    this.locale = stripeLocale(options.locale ?? browserLanguage());
+    this.intervalMs = options.poll?.intervalMs ?? 1e3;
+    this.timeoutMs = options.poll?.timeoutMs ?? 3e4;
+  }
+  /** `loadTuppence`: the key checked here, then what the API says about it. */
+  static async load(publishableKey, options = {}) {
+    const key = typeof publishableKey === "string" ? publishableKey : "";
+    if (/^(sk|rk)_/.test(key)) {
+      throw new TuppenceError({
+        type: "authentication_error",
+        code: "invalid_api_key",
+        message: "That is a secret key: it must never be in a page. Roll it, and pass your publishable key (pk_\u2026) here."
+      });
+    }
+    if (!/^pk_(test|live)_[A-Za-z0-9]+$/.test(key)) {
+      throw new TypeError("loadTuppence needs your publishable key (pk_test_\u2026 or pk_live_\u2026).");
+    }
+    const config = await new _Tuppence(options).http.get("/public/sdk/config", {
+      [PUBLISHABLE_KEY_HEADER]: key
+    });
+    const tuppence = new _Tuppence(options, config);
+    void tuppence.stripeFor(config).catch(() => void 0);
+    return tuppence;
+  }
+  /** The payment a client secret belongs to, as its payer sees it. */
+  retrievePayment(clientSecret) {
+    const id = objectOf(clientSecret, "pay_");
+    return this.http.get(`/public/payments/${id}`, secretHeader(clientSecret));
+  }
+  /** The setup session a client secret belongs to, as its customer sees it. */
+  retrieveSetupSession(clientSecret) {
+    const id = objectOf(clientSecret, "sets_");
+    return this.http.get(
+      `/public/setup_sessions/${id}`,
+      secretHeader(clientSecret)
+    );
+  }
+  /**
+   * Stripe's card fields for a payment — `elements.create("payment").mount(el)` shows them. What
+   * they collect matches the charge Tuppence will make: its amount, currency, how it is
+   * captured and whether it saves the card. Null where no Stripe is behind the environment (the
+   * simulated gateway): there, `testPaymentMethod` names one of Stripe's test cards instead.
+   *
+   * A page that adds to the amount (a tip) says so with `elements.update({ amount })`.
+   */
+  async elements(payment, options = {}) {
+    const stripe = await this.stripeFor(payment);
+    if (!stripe) return null;
+    const { amount, ...look } = options;
+    const excluded = payment.excluded_payment_method_types ?? [];
+    const elements = stripe.elements({
+      ...look,
+      mode: "payment",
+      amount: amount ?? payment.amount,
+      currency: payment.currency,
+      ...payment.capture_method ? { captureMethod: payment.capture_method } : {},
+      ...payment.setup_future_usage ? { setupFutureUsage: payment.setup_future_usage } : {},
+      ...excluded.length > 0 ? { excludedPaymentMethodTypes: [...excluded] } : {}
+    });
+    this.owners.set(elements, stripe);
+    return elements;
+  }
+  /** Stripe's card fields for saving a card with nothing charged — cards only, as the session saves. */
+  async setupElements(session, options = {}) {
+    const stripe = await this.stripeFor(session);
+    if (!stripe) return null;
+    const elements = stripe.elements({ ...options, mode: "setup", paymentMethodTypes: ["card"] });
+    this.owners.set(elements, stripe);
+    return elements;
+  }
+  /**
+   * Stripe's Payment Element for a payment, dressed in the business's branding:
+   * `tuppence.paymentSheet({ clientSecret }).mount("#card")`, then `sheet.confirm()`. Its events
+   * say when the fields show (`ready`), whether they are complete (`change`), and why they
+   * cannot show (`error` — on the simulated gateway there are none).
+   */
+  paymentSheet(options) {
+    return new PaymentSheet(this, options);
+  }
+  /**
+   * A store's basket (85-10): `get()` it, or `quote()` it for an address and a delivery choice
+   * without changing it. On the store's own hosts the basket is its cookie; headless (M94) pass
+   * `base: "https://api.tuppence.ai"`, the publishable key and the basket's token.
+   */
+  cart(options = {}) {
+    return new StorefrontCartClient(this.fetchImpl, options);
+  }
+  /**
+   * Apple Pay, Google Pay and Link for a store's basket (85-10): Stripe's Express Checkout
+   * Element in deferred mode, in the business's branding. The sheet's address and delivery
+   * choices are priced by the basket's quote, and the total in the sheet follows;
+   * `onConfirm` gets Stripe's confirmation token for your server to pay with.
+   * `tuppence.expressCheckout(payable, { onConfirm }).mount("#express")`.
+   */
+  expressCheckout(payable, options) {
+    const cart = options.cart instanceof StorefrontCartClient ? options.cart : this.cart(options.cart);
+    return new ExpressCheckout(this, payable, options, cart);
+  }
+  /**
+   * Stripe's Address Element, with Stripe's autocomplete (85-10): in a payment's own Elements
+   * group (from `elements()`) so a shipping address goes with the payment, or, from a payment
+   * alone, in Elements of its own in the business's branding.
+   */
+  address(from, options) {
+    return new AddressField(this, from, options);
+  }
+  /**
+   * Stripe's confirmation token for fields this SDK made: the fields checked, then the token.
+   * @internal For the SDK's own wallets; pages pay through `confirmPayment`.
+   */
+  async confirmationToken(elements, params) {
+    const stripe = this.owners.get(elements);
+    if (!stripe) {
+      throw new TypeError(
+        "Pass the card fields this SDK made (`tuppence.elements()`): they carry the account the card is for."
+      );
+    }
+    const submitted = await elements.submit();
+    if (submitted.error) return { error: TuppenceError.fromStripe(submitted.error) };
+    const token = await stripe.createConfirmationToken({ elements, ...params ? { params } : {} });
+    if (token.error) return { error: TuppenceError.fromStripe(token.error) };
+    return { id: token.confirmationToken.id };
+  }
+  /** The same for saving a card with nothing charged. */
+  setupSheet(options) {
+    return new SetupSheet(this, options);
+  }
+  /**
+   * Pays a payment: the card is presented (Stripe's fields make a confirmation token), the
+   * payer's bank checks it's them if it asks (in Stripe's own frame), and the payment is read
+   * back until it settles. A refused card is `{ error }` with the payment as it now stands —
+   * never an exception. If an answer is lost on the way, the outcome is read back: the card is
+   * never presented twice.
+   *
+   * A Bacs Direct Debit answers at once with `status: "processing"`, `payment_method_type:
+   * "bacs_debit"` and `processing.expected_debit_date` (`YYYY-MM-DD`): the mandate is set up and
+   * the money is collected in a few working days. Show the payer that; `succeeded` (or
+   * `failed`) comes later, by webhook — `payment.succeeded`, `payment.failed`.
+   */
+  async confirmPayment(options) {
+    const id = objectOf(options.clientSecret, "pay_");
+    const presented = await this.present(options, true);
+    if ("error" in presented) return { error: presented.error, payment: null };
+    const body = options.tipAmount === void 0 ? presented.body : { ...presented.body, tip_amount: options.tipAmount };
+    const outcome = await this.run(
+      `/public/payments/${id}`,
+      options.clientSecret,
+      body
+    );
+    return outcome.error ? { error: outcome.error, payment: outcome.value } : { payment: outcome.value };
+  }
+  /** Saves a card with nothing charged — the same steps as a payment. */
+  async confirmSetup(options) {
+    const id = objectOf(options.clientSecret, "sets_");
+    const presented = await this.present(options, false);
+    if ("error" in presented) return { error: presented.error, setupSession: null };
+    const outcome = await this.run(
+      `/public/setup_sessions/${id}`,
+      options.clientSecret,
+      presented.body
+    );
+    return outcome.error ? { error: outcome.error, setupSession: outcome.value } : { setupSession: outcome.value };
+  }
+  /**
+   * Finishes what a payment waits on when the page opens — the payer's bank checking it's them
+   * (a charge to a saved card that asked for it, a check left half-way) — in Stripe's own frame,
+   * then reads it back. On the simulated gateway it answers the payment as it stands.
+   */
+  async resumePayment(options) {
+    const id = objectOf(options.clientSecret, "pay_");
+    const outcome = await this.resume(
+      `/public/payments/${id}`,
+      options.clientSecret
+    );
+    return outcome.error ? { error: outcome.error, payment: outcome.value } : { payment: outcome.value };
+  }
+  /** The same for a card being saved. */
+  async resumeSetup(options) {
+    const id = objectOf(options.clientSecret, "sets_");
+    const outcome = await this.resume(
+      `/public/setup_sessions/${id}`,
+      options.clientSecret
+    );
+    return outcome.error ? { error: outcome.error, setupSession: outcome.value } : { setupSession: outcome.value };
+  }
+  async resume(path, clientSecret) {
+    const headers = secretHeader(clientSecret);
+    try {
+      return await this.onward(path, headers, await this.http.get(path, headers));
+    } catch (caught) {
+      const error = caught instanceof TuppenceError ? caught : new TuppenceError({ type: "api_error", message: String(caught) });
+      return { error, value: null };
+    }
+  }
+  /**
+   * A bank account, checked and shaped for `POST /v1/accounts/{id}/external_accounts` — the only
+   * way to add one (52-09, 52-17): your server sends `externalAccount` on to Tuppence as
+   * `external_account`, and Tuppence keeps the details (encrypted, for verification) and has Stripe
+   * make the bank account. Tuppence refuses a Stripe bank token. Nothing is sent from
+   * here; a wrong field comes back as an error naming it.
+   */
+  bankAccountDetails(details) {
+    return externalAccountParams(details);
+  }
+  /** Stripe.js for an object's publishable key and account — loaded once for each pair. */
+  stripeFor(view) {
+    const key = view.stripe_publishable_key;
+    const account = view.stripe_account;
+    if (!key || !account) return Promise.resolve(null);
+    const memo = `${key} ${account}`;
+    let loading = this.stripes.get(memo);
+    if (!loading) {
+      loading = this.loadStripe(key, { stripeAccount: account, locale: this.locale });
+      this.stripes.set(memo, loading);
+      loading.catch(() => this.stripes.delete(memo));
+    }
+    return loading;
+  }
+  /** A card, as the confirm route takes it: a confirmation token, a saved card, or a test card. */
+  async present(options, canUseSavedCard) {
+    if (options.elements) {
+      const token = await this.confirmationToken(options.elements, options.params);
+      if ("error" in token) return { error: token.error };
+      return { body: { confirmation_token: token.id } };
+    }
+    if (canUseSavedCard && options.savedCard) {
+      return { body: { saved_card: true } };
+    }
+    if (options.testPaymentMethod) return { body: { payment_method: options.testPaymentMethod } };
+    throw new TypeError(
+      "Present a card: `elements` \u2014 or, on the simulated gateway in test mode, `testPaymentMethod`."
+    );
+  }
+  /** Confirm, then the bank's check if it asks, then read back until it settles. */
+  async run(path, clientSecret, body) {
+    const headers = secretHeader(clientSecret);
+    let current;
+    try {
+      current = await this.http.post(`${path}/confirm`, headers, body);
+    } catch (caught) {
+      const error = caught instanceof TuppenceError ? caught : new TuppenceError({ type: "api_error", message: String(caught) });
+      if (!unknownOutcome(error)) {
+        return { error, value: await this.http.get(path, headers).catch(() => null) };
+      }
+      current = await this.settle(path, headers).catch(() => null);
+      if (!current || current.status === "requires_payment_method") {
+        return { error, value: current };
+      }
+    }
+    return this.onward(path, headers, current);
+  }
+  /** What follows a confirm: the bank's check if it asks, then a read-back until it settles. */
+  async onward(path, headers, confirmed) {
+    let current = confirmed;
+    if (current.status === "requires_action" && current.next_action?.type === "use_stripe_sdk") {
+      const stripe = await this.stripeFor(current);
+      if (!stripe) return { value: current };
+      const handled = await stripe.handleNextAction({
+        clientSecret: current.next_action.stripe_client_secret
+      });
+      current = await this.settle(path, headers).catch(() => null) ?? current;
+      if (handled.error && current.status === "requires_payment_method") {
+        return { error: TuppenceError.fromStripe(handled.error), value: current };
+      }
+    } else if (stillWaiting(current)) {
+      current = await this.settle(path, headers).catch(() => null) ?? current;
+    }
+    if (current.status === "requires_payment_method" && current.last_error) {
+      return { error: refused(current.last_error), value: current };
+    }
+    return { value: current };
+  }
+  /** Reads an object back until neither the bank nor Stripe is still deciding, or time is up. */
+  async settle(path, headers) {
+    let current = await this.http.get(path, headers);
+    for (let waited = 0; stillWaiting(current) && waited < this.timeoutMs; ) {
+      await this.sleep(this.intervalMs);
+      waited += this.intervalMs;
+      current = await this.http.get(path, headers);
+    }
+    return current;
+  }
+};
+function createTuppence(options = {}) {
+  return new Tuppence(options);
+}
+function loadTuppence(publishableKey, options = {}) {
+  return Tuppence.load(publishableKey, options);
+}