@tagadapay/headless-sdk 1.7.0 → 1.8.0

package/dist/tagada-headless.js

@@ -1,2229 +0,0 @@
-/**
- * @tagadapay/headless-sdk v1.7.0
- * Headless checkout, payments, offers, and CRM
- * @license MIT
- */
-"use strict";
-var TagadaHeadlessBundle = (() => {
-  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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined")
-      return require.apply(this, arguments);
-    throw Error('Dynamic require of "' + x + '" is not supported');
-  });
-  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/core/index.ts
-  var core_exports = {};
-  __export(core_exports, {
-    AVAILABLE_LANGUAGES: () => AVAILABLE_LANGUAGES,
-    CatalogModule: () => CatalogModule,
-    CheckoutModule: () => CheckoutModule,
-    CurrencyUtils: () => CurrencyUtils,
-    CustomerModule: () => CustomerModule,
-    FunnelModule: () => FunnelModule,
-    GoogleAutocompleteCore: () => GoogleAutocompleteCore,
-    HeadlessClient: () => HeadlessClient,
-    HttpClient: () => HttpClient,
-    ISODataCore: () => ISODataCore,
-    OffersModule: () => OffersModule,
-    PaymentModule: () => PaymentModule,
-    TagadaAuthError: () => TagadaAuthError,
-    TagadaError: () => TagadaError,
-    TagadaNetworkError: () => TagadaNetworkError,
-    TagadaNotFoundError: () => TagadaNotFoundError,
-    TagadaPaymentError: () => TagadaPaymentError,
-    TagadaRateLimitError: () => TagadaRateLimitError,
-    TagadaValidationError: () => TagadaValidationError,
-    createHeadlessClient: () => createHeadlessClient,
-    ensureGeoDataLoaded: () => ensureGeoDataLoaded,
-    formatMoney: () => formatMoney,
-    getCountries: () => getCountries,
-    getStatesForCountry: () => getStatesForCountry,
-    isLanguageLoaded: () => isLanguageLoaded,
-    loadGoogleMapsScript: () => loadGoogleMapsScript
-  });
-
-  // src/core/errors.ts
-  var TagadaError = class extends Error {
-    constructor(message, code, statusCode, details) {
-      super(message);
-      this.name = "TagadaError";
-      this.code = code;
-      this.statusCode = statusCode;
-      this.details = details;
-    }
-  };
-  var TagadaAuthError = class extends TagadaError {
-    constructor(message = "Authentication failed. Check your API key or checkout token.") {
-      super(message, "auth_error", 401);
-      this.name = "TagadaAuthError";
-    }
-  };
-  var TagadaValidationError = class extends TagadaError {
-    constructor(message, errors = []) {
-      super(message, "validation_error", 422, { errors });
-      this.name = "TagadaValidationError";
-      this.errors = errors;
-    }
-  };
-  var TagadaNotFoundError = class extends TagadaError {
-    constructor(resource, id) {
-      super(`${resource} "${id}" not found.`, "not_found", 404);
-      this.name = "TagadaNotFoundError";
-    }
-  };
-  var TagadaRateLimitError = class extends TagadaError {
-    constructor(retryAfterMs = 1e3) {
-      super(`Rate limited. Retry after ${retryAfterMs}ms.`, "rate_limit", 429);
-      this.name = "TagadaRateLimitError";
-      this.retryAfterMs = retryAfterMs;
-    }
-  };
-  var TagadaPaymentError = class extends TagadaError {
-    constructor(message, opts) {
-      super(message, "payment_error", void 0, opts == null ? void 0 : opts.details);
-      this.name = "TagadaPaymentError";
-      this.paymentId = opts == null ? void 0 : opts.paymentId;
-      this.requireAction = opts == null ? void 0 : opts.requireAction;
-    }
-  };
-  var TagadaNetworkError = class extends TagadaError {
-    constructor(message = "Network request failed. Check your connection.") {
-      super(message, "network_error");
-      this.name = "TagadaNetworkError";
-    }
-  };
-
-  // src/core/http.ts
-  var BASE_URLS = {
-    production: "https://api.tagada.io",
-    development: "https://api.tagada.dev",
-    local: "http://localhost:3000"
-  };
-  var HttpClient = class {
-    constructor(config) {
-      this.baseUrl = config.baseUrl.replace(/\/$/, "");
-      this.timeout = config.timeout;
-      this.apiKey = config.apiKey;
-      this.getToken = config.getToken;
-    }
-    static resolveBaseUrl(environment, override) {
-      return override ?? BASE_URLS[environment] ?? BASE_URLS.production;
-    }
-    async request(path, options = {}) {
-      var _a;
-      const { method = "GET", body, headers = {}, params, token, signal } = options;
-      let url = `${this.baseUrl}${path}`;
-      if (params) {
-        const qs = new URLSearchParams();
-        for (const [k, v] of Object.entries(params)) {
-          if (v !== void 0)
-            qs.set(k, String(v));
-        }
-        const str = qs.toString();
-        if (str)
-          url += `?${str}`;
-      }
-      const reqHeaders = {
-        "Content-Type": "application/json",
-        ...headers
-      };
-      const authToken = token ?? this.apiKey ?? ((_a = this.getToken) == null ? void 0 : _a.call(this));
-      if (authToken) {
-        reqHeaders["x-cms-token"] = authToken;
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const res = await fetch(url, {
-          method,
-          headers: reqHeaders,
-          body: body != null ? JSON.stringify(body) : void 0,
-          signal: signal ?? controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (res.ok) {
-          const text = await res.text();
-          return text ? JSON.parse(text) : {};
-        }
-        await this.handleErrorResponse(res, path);
-        throw new TagadaError("Unexpected error", "unknown", res.status);
-      } catch (err) {
-        clearTimeout(timeoutId);
-        if (err instanceof TagadaError)
-          throw err;
-        if (err instanceof DOMException && err.name === "AbortError") {
-          throw new TagadaNetworkError(`Request to ${path} timed out after ${this.timeout}ms.`);
-        }
-        throw new TagadaNetworkError(
-          err instanceof Error ? err.message : "Network request failed."
-        );
-      }
-    }
-    get(path, options) {
-      return this.request(path, { ...options, method: "GET" });
-    }
-    post(path, body, options) {
-      return this.request(path, { ...options, method: "POST", body });
-    }
-    patch(path, body, options) {
-      return this.request(path, { ...options, method: "PATCH", body });
-    }
-    put(path, body, options) {
-      return this.request(path, { ...options, method: "PUT", body });
-    }
-    delete(path, options) {
-      return this.request(path, { ...options, method: "DELETE" });
-    }
-    async handleErrorResponse(res, path) {
-      let parsed = {};
-      try {
-        parsed = await res.json();
-      } catch {
-      }
-      const msg = parsed.message ?? parsed.error ?? `Request failed: ${res.status} ${res.statusText} on ${path}`;
-      switch (res.status) {
-        case 401:
-        case 403:
-          throw new TagadaAuthError(msg);
-        case 404:
-          throw new TagadaNotFoundError(path, "");
-        case 422: {
-          const fieldErrors = Array.isArray(parsed.errors) ? parsed.errors : [];
-          throw new TagadaValidationError(msg, fieldErrors);
-        }
-        case 429: {
-          const retryAfter = Number(res.headers.get("Retry-After") ?? "1") * 1e3;
-          throw new TagadaRateLimitError(retryAfter);
-        }
-        default:
-          throw new TagadaError(msg, "api_error", res.status, parsed);
-      }
-    }
-  };
-
-  // src/core/modules/checkout.ts
-  var CheckoutModule = class {
-    constructor(http, storeId, onTokenChange) {
-      this.http = http;
-      this.storeId = storeId;
-      this.onTokenChange = onTokenChange;
-    }
-    /**
-     * Returns the most recently loaded `CheckoutSession`, if any.
-     *
-     * Populated by `loadSession()`. Returns `undefined` if the SDK has not
-     * loaded a session yet. Used by `funnel.navigate()` to source the cart.
-     */
-    getCurrentSession() {
-      return this._currentSession;
-    }
-    /**
-     * Load an existing checkout session by its checkout token.
-     *
-     * @param checkoutToken The checkout token (from URL param `checkoutToken`).
-     * @param sessionToken The JWT session token (from URL param `token`). Required for auth.
-     * @param opts.currency Optional presentment currency override (e.g. 'EUR').
-     *   Only applied when the session has no currency set yet (first load).
-     *   Once set, currency is locked to the session and this param is ignored.
-     *
-     * Both `checkoutToken` and `sessionToken` come from the redirect URL returned by `createSession()`.
-     * Example URL: `/checkout?checkoutToken=abc123&token=eyJ...`
-     */
-    async loadSession(checkoutToken, sessionToken, opts) {
-      var _a;
-      if (sessionToken) {
-        this.sessionToken = sessionToken;
-        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
-      }
-      const params = { skipAsyncWait: "false" };
-      if (opts == null ? void 0 : opts.currency) {
-        params.currency = opts.currency;
-      }
-      const raw = await this.http.get(
-        `/api/v1/checkout-sessions/${checkoutToken}/v2`,
-        {
-          params,
-          token: this.sessionToken
-        }
-      );
-      const session = this.normalizeSession(raw);
-      this._currentSession = session;
-      return session;
-    }
-    /**
-     * Create a new checkout session.
-     *
-     * Returns a `checkoutToken` and `sessionToken` (JWT) needed for all subsequent calls.
-     * Also returns a `checkoutUrl` (the full Tagada-hosted checkout URL, for reference).
-     */
-    async createSession(opts) {
-      var _a;
-      const lineItems = opts.items.map((i) => ({
-        variantId: i.variantId,
-        priceId: i.priceId,
-        quantity: i.quantity
-      }));
-      const body = {
-        storeId: this.storeId,
-        lineItems
-      };
-      if (opts.returnUrl)
-        body.returnUrl = opts.returnUrl;
-      const customerData = {};
-      if (opts.currency)
-        customerData.currency = opts.currency;
-      if (opts.customerEmail) {
-        customerData.email = opts.customerEmail;
-        customerData.firstName = opts.customerFirstName;
-        customerData.lastName = opts.customerLastName;
-      }
-      if (Object.keys(customerData).length > 0) {
-        body.customer = customerData;
-      }
-      const res = await this.http.post("/api/v1/checkout/session/init", body);
-      const url = new URL(res.checkoutUrl);
-      const sessionToken = url.searchParams.get("token") ?? "";
-      this.sessionToken = sessionToken;
-      if (sessionToken)
-        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
-      return {
-        checkoutUrl: res.checkoutUrl,
-        checkoutToken: res.checkoutToken,
-        sessionToken,
-        customerId: res.customerId
-      };
-    }
-    /**
-     * Create a session and produce a self-hosted redirect URL.
-     *
-     * Convenience wrapper around `createSession()`. Builds a URL of the
-     * form `${origin}${checkoutPath}?checkoutToken=...&sessionToken=...`
-     * that you can navigate to from a Cart page. The receiving page reads
-     * the params via {@link CheckoutModule.parseTokensFromUrl} and calls
-     * {@link CheckoutModule.loadSession}.
-     *
-     * For Tagada-hosted checkouts use the `checkoutUrl` returned by
-     * `createSession()` directly — this helper is for **self-hosted**
-     * checkout pages.
-     *
-     * @example
-     * ```ts
-     * const { url } = await tagada.checkout.createSessionUrl({
-     *   items: [{ variantId, quantity: 1 }],
-     *   checkoutPath: '/checkout',
-     * });
-     * window.location.href = url;
-     * ```
-     */
-    async createSessionUrl(opts) {
-      const session = await this.createSession({
-        items: opts.items,
-        currency: opts.currency,
-        returnUrl: opts.returnUrl,
-        customerEmail: opts.customerEmail,
-        customerFirstName: opts.customerFirstName,
-        customerLastName: opts.customerLastName
-      });
-      const origin = opts.origin ?? (typeof window !== "undefined" ? window.location.origin : "");
-      const checkoutPath = opts.checkoutPath ?? "/checkout";
-      const params = new URLSearchParams({
-        checkoutToken: session.checkoutToken,
-        sessionToken: session.sessionToken
-      });
-      const url = `${origin}${checkoutPath}?${params.toString()}`;
-      return { ...session, url };
-    }
-    /**
-     * Read `checkoutToken` and session token from a URL.
-     *
-     * Recognizes both the SDK convention (`?sessionToken=`) and the
-     * Tagada-hosted convention (`?token=`), so the same checkout page
-     * works whether the user came from `createSessionUrl()` or directly
-     * from a Tagada-hosted redirect.
-     *
-     * Returns `null` if `checkoutToken` is missing.
-     *
-     * @example
-     * ```ts
-     * const tokens = CheckoutModule.parseTokensFromUrl();
-     * if (!tokens) {
-     *   window.location.href = '/cart';
-     *   return;
-     * }
-     * const session = await tagada.checkout.loadSession(
-     *   tokens.checkoutToken,
-     *   tokens.sessionToken,
-     * );
-     * ```
-     */
-    static parseTokensFromUrl(url) {
-      if (typeof url === "undefined" && typeof window === "undefined")
-        return null;
-      const href = url ?? window.location.href;
-      let parsed;
-      try {
-        parsed = new URL(href);
-      } catch {
-        return null;
-      }
-      const checkoutToken = parsed.searchParams.get("checkoutToken");
-      if (!checkoutToken)
-        return null;
-      const sessionToken = parsed.searchParams.get("sessionToken") ?? parsed.searchParams.get("token") ?? "";
-      return { checkoutToken, sessionToken };
-    }
-    /**
-     * Replace the cart items for an existing session.
-     *
-     * Returns a server-side mutation summary (counts of created/updated rows).
-     * It does NOT return the updated `CheckoutSession` — the underlying
-     * `POST /checkout-sessions/:id/line-items` endpoint never has and the
-     * previous typing was a lie that quietly assigned `{ success, updated, ... }`
-     * into a `CheckoutSession` slot in `useCheckout`.
-     *
-     * Call `loadSession()` after this if you need the refreshed session
-     * (the React `useCheckout` hook does this for you).
-     */
-    async updateCart(sessionId, items) {
-      return this.http.post(
-        `/api/v1/checkout-sessions/${sessionId}/line-items`,
-        { items },
-        { token: this.sessionToken }
-      );
-    }
-    /**
-     * Update customer identity (email, name, phone).
-     *
-     * Call this before `updateAddress()` — the SDK remembers the values and
-     * includes them automatically when addresses are submitted.
-     *
-     * If you prefer a single call, use `updateCustomerAndAddress()` instead.
-     */
-    async updateCustomer(sessionId, customer) {
-      if (customer.email)
-        this.customerEmail = customer.email;
-      if (customer.firstName)
-        this.customerFirstName = customer.firstName;
-      if (customer.lastName)
-        this.customerLastName = customer.lastName;
-      if (customer.phone)
-        this.customerPhone = customer.phone;
-    }
-    /**
-     * Update shipping and/or billing address on the session.
-     *
-     * Automatically includes customer name/phone stored from `updateCustomer()`.
-     * Uses the same atomic API call as the production checkout, so email,
-     * customer name, and addresses are all persisted together.
-     *
-     * **Shipped products**: pass `shippingAddress`. If `billingAddress` is omitted,
-     * the shipping address is automatically used as billing.
-     *
-     * **Digital products**: pass only `billingAddress` (no shipping needed).
-     *
-     * @example
-     * // Shipped product — billing = shipping automatically
-     * await checkout.updateAddress(sessionId, {
-     *   shippingAddress: { line1: '10 Rue de la Paix', city: 'Paris', postalCode: '75002', country: 'FR' },
-     * });
-     *
-     * @example
-     * // Digital product — billing only
-     * await checkout.updateAddress(sessionId, {
-     *   billingAddress: { country: 'FR' },
-     * });
-     */
-    async updateAddress(sessionId, addresses) {
-      const shipping = this.mapAddress(addresses.shippingAddress);
-      const billing = this.mapAddress(addresses.billingAddress);
-      const effectiveShipping = shipping ?? billing ?? {};
-      const effectiveBilling = billing ?? shipping;
-      const differentBilling = !!(addresses.billingAddress && addresses.shippingAddress);
-      await this.http.post(
-        `/api/v1/checkout-sessions/${sessionId}/customer-and-session-info`,
-        {
-          checkoutSessionId: sessionId,
-          customerData: {
-            email: this.customerEmail
-          },
-          shippingAddress: effectiveShipping,
-          billingAddress: effectiveBilling ?? {},
-          differentBillingAddress: differentBilling
-        },
-        { token: this.sessionToken }
-      );
-    }
-    /**
-     * Set customer info + addresses in one call (mirrors production checkout).
-     *
-     * Equivalent to calling `updateCustomer()` then `updateAddress()`, but
-     * in a single network request.
-     */
-    async updateCustomerAndAddress(sessionId, data) {
-      if (data.customer.email)
-        this.customerEmail = data.customer.email;
-      if (data.customer.firstName)
-        this.customerFirstName = data.customer.firstName;
-      if (data.customer.lastName)
-        this.customerLastName = data.customer.lastName;
-      if (data.customer.phone)
-        this.customerPhone = data.customer.phone;
-      const shipping = this.mapAddress(data.shippingAddress);
-      const billing = this.mapAddress(data.billingAddress);
-      const effectiveShipping = shipping ?? billing ?? {};
-      const effectiveBilling = billing ?? shipping;
-      const differentBilling = !!(data.billingAddress && data.shippingAddress);
-      await this.http.post(
-        `/api/v1/checkout-sessions/${sessionId}/customer-and-session-info`,
-        {
-          checkoutSessionId: sessionId,
-          customerData: {
-            email: this.customerEmail
-          },
-          shippingAddress: effectiveShipping,
-          billingAddress: effectiveBilling ?? {},
-          differentBillingAddress: differentBilling
-        },
-        { token: this.sessionToken }
-      );
-    }
-    /** Map an SDK Address to the API shape, injecting stored customer fields. */
-    mapAddress(a) {
-      if (!a)
-        return void 0;
-      return stripEmpty({
-        firstName: a.firstName ?? this.customerFirstName,
-        lastName: a.lastName ?? this.customerLastName,
-        phone: a.phone ?? this.customerPhone,
-        address1: a.line1,
-        address2: a.line2,
-        city: a.city,
-        state: a.state,
-        postal: a.postalCode,
-        country: a.country
-      });
-    }
-    /** Apply a promotion code to the session. */
-    async applyPromoCode(sessionId, code) {
-      await this.http.post(
-        `/api/v1/checkout-sessions/${sessionId}/promotions/apply`,
-        { checkoutSessionId: sessionId, code },
-        { token: this.sessionToken }
-      );
-    }
-    /** Remove a promotion from the session by promotion ID. */
-    async removePromoCode(sessionId, promotionId) {
-      const promoId = promotionId ?? "default";
-      await this.http.delete(
-        `/api/v1/checkout-sessions/${sessionId}/promotions/${promoId}`,
-        { token: this.sessionToken }
-      );
-    }
-    /**
-     * Fetch available shipping rates for the session's address.
-     * Only relevant for **shipped products** — digital products can skip this step.
-     *
-     * Requires a shipping address to be set first via `updateAddress()`.
-     * Returns an empty array if no rates are configured or address is missing.
-     */
-    async getShippingRates(sessionId) {
-      const res = await this.http.get(
-        `/api/v1/checkout-sessions/${sessionId}/shipping-rates`,
-        { token: this.sessionToken }
-      );
-      return (res.rates ?? []).map((r) => this.normalizeShippingRate(r));
-    }
-    /**
-     * Normalize the v1 rates payload (`shippingRateName`, `estimatedDeliveryTime`)
-     * to the SDK's `ShippingRate` shape (`name`, `estimatedDays`). Without
-     * this the consumer's UI shows blank rate names — the demo's "Delivery"
-     * radios were rendering only the price, no label.
-     */
-    normalizeShippingRate(r) {
-      return {
-        id: r.id,
-        name: r.name ?? r.shippingRateName ?? "",
-        description: r.description ?? void 0,
-        amount: r.amount ?? 0,
-        currency: r.currency ?? "USD",
-        estimatedDays: r.estimatedDays ?? r.estimatedDeliveryTime ?? void 0
-      };
-    }
-    /**
-     * Select a shipping rate for the session.
-     * Only relevant for **shipped products** — digital products can skip this step.
-     */
-    async selectShippingRate(sessionId, rateId) {
-      await this.http.post(
-        `/api/v1/checkout-sessions/${sessionId}/shipping-rate`,
-        { checkoutSessionId: sessionId, shippingRateId: rateId },
-        { token: this.sessionToken }
-      );
-    }
-    /**
-     * Normalize the raw v2 API response into a cleaner CheckoutSession shape.
-     * The raw response has nested `checkoutSession` + `summary` -- we flatten it.
-     */
-    normalizeSession(raw) {
-      var _a;
-      const cs = raw.checkoutSession;
-      const orderSummaries = cs.orderSummaries ?? [];
-      const summary = raw.summary ?? cs.summary ?? orderSummaries[0] ?? {};
-      const lineItems = cs.sessionLineItems ?? [];
-      const customer = cs.customer;
-      const sessionCurrency = (_a = summary.currency ?? cs.selectedPresentmentCurrency) == null ? void 0 : _a.toUpperCase();
-      const items = lineItems.map((li) => {
-        const price = li.price;
-        const variant = li.variant ?? (price == null ? void 0 : price.variant) ?? {};
-        const product = li.product ?? variant.product ?? {};
-        const currencyOpts = (price == null ? void 0 : price.currencyOptions) ?? {};
-        const priceEntry = (sessionCurrency ? currencyOpts[sessionCurrency] : void 0) ?? currencyOpts[Object.keys(currencyOpts)[0]];
-        const amount = (priceEntry == null ? void 0 : priceEntry.amount) ?? 0;
-        return {
-          id: li.id,
-          variantId: li.variantId,
-          priceId: li.priceId,
-          productName: product.name ?? "",
-          variantName: variant.name ?? "",
-          quantity: li.quantity ?? 1,
-          unitAmount: amount,
-          totalAmount: amount * (li.quantity ?? 1),
-          currency: sessionCurrency ?? "USD",
-          imageUrl: variant.imageUrl ?? product.imageUrl ?? ""
-        };
-      });
-      const summaryItems = summary.items ?? [];
-      return {
-        id: cs.id,
-        storeId: cs.storeId,
-        checkoutToken: cs.checkoutToken,
-        currency: sessionCurrency ?? "USD",
-        items,
-        totals: {
-          subtotal: summary.subtotalAmount ?? 0,
-          discount: summary.totalPromotionAmount ?? 0,
-          shipping: summary.shippingCost ?? 0,
-          tax: summary.totalTaxAmount ?? 0,
-          total: summary.totalAmount ?? summaryItems.reduce((s, i) => s + (i.amount ?? 0), 0),
-          currency: sessionCurrency ?? "USD"
-        },
-        customer: customer ? {
-          id: customer.id,
-          email: customer.email,
-          firstName: customer.firstName,
-          lastName: customer.lastName,
-          phone: customer.phone
-        } : void 0,
-        shippingAddress: this.normalizeAddress(cs.shippingAddress),
-        billingAddress: this.normalizeAddress(cs.billingAddress),
-        selectedShippingRateId: cs.shippingRateId ?? null,
-        metadata: cs.metadata
-      };
-    }
-    /**
-     * Map the raw API address shape (`address1`, `address2`, `postal`) onto
-     * the SDK's `Address` shape (`line1`, `line2`, `postalCode`). Without
-     * this, `session.shippingAddress.line1` is silently undefined after a
-     * reload — the type was lying about the actual key names — which is
-     * what makes the demo lose form state on refresh.
-     */
-    normalizeAddress(raw) {
-      if (!raw || typeof raw !== "object")
-        return void 0;
-      const a = raw;
-      const out = {
-        firstName: a.firstName,
-        lastName: a.lastName,
-        line1: a.line1 ?? a.address1,
-        line2: a.line2 ?? a.address2,
-        city: a.city,
-        state: a.state,
-        postalCode: a.postalCode ?? a.postal,
-        country: a.country,
-        phone: a.phone
-      };
-      return Object.values(out).some((v) => v !== void 0 && v !== "") ? out : void 0;
-    }
-  };
-  function stripEmpty(obj) {
-    const result = {};
-    for (const [k, v] of Object.entries(obj)) {
-      if (v !== void 0 && v !== null && v !== "") {
-        result[k] = v;
-      }
-    }
-    return Object.keys(result).length > 0 ? result : void 0;
-  }
-
-  // src/core/modules/payment.ts
-  var PaymentModule = class {
-    constructor(http, storeId, environment) {
-      this.http = http;
-      this.storeId = storeId;
-      this.environment = environment;
-    }
-    // ---------------------------------------------------------------------------
-    // Discovery: what payment methods are available?
-    // ---------------------------------------------------------------------------
-    /**
-     * Get the full payment setup config for a checkout session.
-     * Returns a map of payment methods with their configuration
-     * (card, apple_pay, google_pay, klarna, etc.).
-     *
-     * Priority chain:
-     * 1. Explicit `paymentSetupConfig` parameter (developer override)
-     * 2. `window.__TGD_STEP_CONFIG__` injection (Tagada routing infra)
-     * 3. API fallback (`GET /api/v1/payment-methods`)
-     */
-    async getPaymentSetup(checkoutSessionId, opts) {
-      if (opts == null ? void 0 : opts.paymentSetupConfig) {
-        return opts.paymentSetupConfig;
-      }
-      const injected = this.readInjectedStepConfig();
-      if (injected) {
-        return injected;
-      }
-      const methods = await this.http.get(
-        "/api/v1/payment-methods",
-        { params: { checkoutSessionId } }
-      );
-      const config = {};
-      for (const m of methods.methods ?? []) {
-        const key = m.provider ? `${m.method}:${m.provider}` : m.method;
-        config[key] = m;
-      }
-      return config;
-    }
-    /**
-     * Get express payment methods (Apple Pay, Google Pay, PayPal, etc.)
-     * filtered to only those available in the current browser.
-     */
-    async getExpressMethods(checkoutSessionId, opts) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-      const setup = await this.getPaymentSetup(checkoutSessionId, opts);
-      const result = {};
-      for (const [key, config] of Object.entries(setup)) {
-        if (!config.enabled)
-          continue;
-        if (key.startsWith("express_checkout:") && config.methods) {
-          const base2 = {
-            available: true,
-            processorId: config.processorId,
-            publishableKey: config.publishableKey,
-            metadata: config.metadata
-          };
-          if ((_a = config.methods.apple_pay) == null ? void 0 : _a.enabled) {
-            const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_c = (_b = window.ApplePaySession) == null ? void 0 : _b.canMakePayments) == null ? void 0 : _c.call(_b));
-            result.applePay = { ...base2, type: "apple_pay", available: !!hasApplePay };
-          }
-          if ((_d = config.methods.google_pay) == null ? void 0 : _d.enabled) {
-            result.googlePay = { ...base2, type: "google_pay" };
-          }
-          if ((_e = config.methods.paypal) == null ? void 0 : _e.enabled) {
-            result.paypal = { ...base2, type: "paypal" };
-          }
-          if ((_f = config.methods.link) == null ? void 0 : _f.enabled) {
-            result.link = { ...base2, type: "link" };
-          }
-          if ((_g = config.methods.klarna_express) == null ? void 0 : _g.enabled) {
-            result.klarna = { ...base2, type: "klarna_express" };
-          }
-          continue;
-        }
-        if (!config.express)
-          continue;
-        const method = config.method;
-        const base = {
-          type: method,
-          available: true,
-          processorId: config.processorId,
-          publishableKey: config.publishableKey,
-          metadata: config.metadata
-        };
-        if (method === "apple_pay" || config.type === "apple_pay") {
-          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_i = (_h = window.ApplePaySession) == null ? void 0 : _h.canMakePayments) == null ? void 0 : _i.call(_h));
-          result.applePay = { ...base, available: !!hasApplePay };
-        } else if (method === "google_pay" || config.type === "google_pay") {
-          result.googlePay = base;
-        } else if (method === "paypal") {
-          result.paypal = base;
-        } else if (method === "klarna" || method === "klarna_express") {
-          result.klarna = base;
-        } else if (method === "link") {
-          result.link = base;
-        }
-      }
-      return result;
-    }
-    /**
-     * Get store-level payment config (3DS flags, default flow ID, etc.).
-     */
-    async getStoreConfig() {
-      const res = await this.http.get(
-        "/api/v1/checkout/config",
-        { params: { storeId: this.storeId } }
-      );
-      return res.config ?? res;
-    }
-    /**
-     * Convenience: return only enabled payment method keys.
-     */
-    async getEnabledMethods(checkoutSessionId, opts) {
-      const setup = await this.getPaymentSetup(checkoutSessionId, opts);
-      return Object.entries(setup).filter(([, c]) => c.enabled).map(([key]) => key);
-    }
-    // ---------------------------------------------------------------------------
-    // Tokenization (delegates to @tagadapay/core-js if available)
-    // ---------------------------------------------------------------------------
-    /**
-     * Tokenize a card using @tagadapay/core-js.
-     * Requires `@tagadapay/core-js` to be installed as a peer dependency.
-     *
-     * Card data is sent directly to Basis Theory for tokenization and never
-     * reaches TagadaPay servers. The returned `tagadaToken` is safe to pass
-     * to the TagadaPay API.
-     *
-     * **PCI note:** Using this method means card data passes through your
-     * JavaScript environment. You are responsible for PCI DSS SAQ-A-EP
-     * compliance. See https://docs.tagada.io/developer-tools/headless-sdk/pci-compliance
-     *
-     * @returns tagadaToken (base64 string) and rawToken with SCA metadata.
-     */
-    async tokenizeCard(card) {
-      const coreJs = await this.loadCoreJs();
-      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
-      await tokenizer.initialize();
-      const sanitized = {
-        cardNumber: card.cardNumber,
-        expiryDate: card.expiryDate,
-        cvc: card.cvc
-      };
-      if (card.cardholderName)
-        sanitized.cardholderName = card.cardholderName;
-      const rawToken = await tokenizer.tokenizeCardRaw(sanitized);
-      const tagadaToken = coreJs.createTagadaToken(
-        rawToken,
-        tokenizer.getProvider().getProviderName()
-      );
-      return { tagadaToken, rawToken };
-    }
-    // ---------------------------------------------------------------------------
-    // Instrument creation
-    // ---------------------------------------------------------------------------
-    /**
-     * Create a reusable payment instrument from a TagadaToken.
-     * Session-authenticated (uses the checkout session JWT).
-     */
-    async createInstrument(opts) {
-      return this.http.post("/api/v1/payment/create-instrument-from-token", {
-        tagadaToken: opts.tagadaToken
-      });
-    }
-    // ---------------------------------------------------------------------------
-    // 3DS
-    // ---------------------------------------------------------------------------
-    /**
-     * Create a 3DS session on the TagadaPay backend.
-     * This persists the session so the processor can use it during payment.
-     */
-    async create3dsSession(opts) {
-      return this.http.post("/api/public/v1/threeds/create-session", {
-        provider: opts.provider ?? "basis_theory",
-        storeId: this.storeId,
-        paymentInstrumentId: opts.paymentInstrumentId,
-        sessionData: opts.sessionData
-      });
-    }
-    // ---------------------------------------------------------------------------
-    // Payment processing
-    // ---------------------------------------------------------------------------
-    /**
-     * High-level pay: single API call that decodes tagadaToken server-side,
-     * creates the payment instrument, and processes payment.
-     *
-     * Also accepts `paymentInstrumentId` directly for pre-created instruments.
-     */
-    async pay(opts) {
-      if (opts.tagadaToken && !opts.paymentInstrumentId) {
-        return this.http.post("/api/v1/payment/pay-with-token", {
-          tagadaToken: opts.tagadaToken,
-          checkoutSessionId: opts.checkoutSessionId,
-          returnUrl: opts.returnUrl,
-          paymentFlowId: opts.paymentFlowId,
-          processorId: opts.processorId,
-          paymentMethod: opts.paymentMethod,
-          isExpress: opts.isExpress,
-          metadata: opts.metadata
-        });
-      }
-      return this.http.post("/api/public/v1/checkout/pay-v2", {
-        checkoutSessionId: opts.checkoutSessionId,
-        paymentInstrumentId: opts.paymentInstrumentId,
-        storeId: this.storeId,
-        paymentFlowId: opts.paymentFlowId,
-        threedsSessionId: opts.threedsSessionId,
-        processorId: opts.processorId,
-        paymentMethod: opts.paymentMethod,
-        isExpress: opts.isExpress,
-        metadata: opts.metadata
-      });
-    }
-    /**
-     * Low-level pay: process payment with an existing instrument or for APM/express flows
-     * where no instrument is needed (redirect-based methods).
-     */
-    async payDirect(opts) {
-      return this.http.post("/api/public/v1/checkout/pay-v2", {
-        checkoutSessionId: opts.checkoutSessionId,
-        paymentInstrumentId: opts.paymentInstrumentId ?? "",
-        storeId: this.storeId,
-        paymentFlowId: opts.paymentFlowId,
-        processorId: opts.processorId,
-        paymentMethod: opts.paymentMethod,
-        isExpress: opts.isExpress,
-        threedsSessionId: opts.threedsSessionId
-      });
-    }
-    /**
-     * Process an Apple Pay payment.
-     * Tokenizes the Apple Pay token and processes payment in one call.
-     */
-    async processApplePay(opts) {
-      const coreJs = await this.loadCoreJs();
-      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
-      await tokenizer.initialize();
-      const { tagadaToken } = await tokenizer.tokenizeApplePay(opts.applePayToken);
-      return this.pay({
-        checkoutSessionId: opts.checkoutSessionId,
-        tagadaToken,
-        paymentFlowId: opts.paymentFlowId,
-        processorId: opts.processorId,
-        paymentMethod: "apple_pay",
-        isExpress: true
-      });
-    }
-    /**
-     * Process a Google Pay payment.
-     * Tokenizes the Google Pay token and processes payment in one call.
-     */
-    async processGooglePay(opts) {
-      const coreJs = await this.loadCoreJs();
-      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
-      await tokenizer.initialize();
-      const { tagadaToken } = await tokenizer.tokenizeGooglePay(opts.googlePayToken);
-      return this.pay({
-        checkoutSessionId: opts.checkoutSessionId,
-        tagadaToken,
-        paymentFlowId: opts.paymentFlowId,
-        processorId: opts.processorId,
-        paymentMethod: "google_pay",
-        isExpress: true
-      });
-    }
-    /**
-     * Process an APM payment (Klarna, iDEAL, etc.) via redirect.
-     * These typically don't require a payment instrument -- the processor handles the redirect.
-     */
-    async processApm(opts) {
-      return this.payDirect({
-        checkoutSessionId: opts.checkoutSessionId,
-        paymentMethod: opts.paymentMethod,
-        processorId: opts.processorId,
-        paymentFlowId: opts.paymentFlowId
-      });
-    }
-    /**
-     * Initiate a Stripe Express Checkout payment (Apple Pay, Google Pay, Link, etc.).
-     *
-     * Calls `pay-v2` with `isExpress: true`, which returns a `clientSecret` in
-     * `payment.requireActionData.metadata.stripeExpressCheckout.clientSecret`.
-     * The caller must then call `stripe.confirmPayment()` with that secret.
-     *
-     * Used by the `StripeExpressCheckout` class and `useStripeExpress` hook.
-     * Not typically called directly — use the Stripe integration classes instead.
-     */
-    async processStripeExpress(opts) {
-      return this.payDirect({
-        checkoutSessionId: opts.checkoutSessionId,
-        processorId: opts.processorId,
-        paymentMethod: opts.paymentMethod,
-        isExpress: true
-      });
-    }
-    // ---------------------------------------------------------------------------
-    // High-level orchestrator — the ONE function beginners should call
-    // ---------------------------------------------------------------------------
-    /**
-     * Process a payment end-to-end: pay, handle 3DS / redirects, poll until done.
-     *
-     * This is the **recommended** way to process payments. It wraps `pay()`, detects
-     * `requireAction`, runs 3DS challenges (if `@tagadapay/core-js` is installed),
-     * and polls until a terminal status.
-     *
-     * Returns a discriminated union so you can pattern-match on `result.status`:
-     *
-     * @example
-     * ```ts
-     * const result = await payment.processPayment({
-     *   checkoutSessionId: session.id,
-     *   tagadaToken,
-     * });
-     *
-     * switch (result.status) {
-     *   case 'succeeded':
-     *     console.log('Paid!', result.payment.id);
-     *     break;
-     *   case 'requires_redirect':
-     *     // In browser: window.location.href = result.redirectUrl
-     *     // The React hook handles this automatically.
-     *     break;
-     *   case 'failed':
-     *     console.error(result.error);
-     *     break;
-     * }
-     * ```
-     */
-    async processPayment(opts) {
-      if (!opts.returnUrl && typeof window !== "undefined") {
-        opts = { ...opts, returnUrl: window.location.href };
-      }
-      const payResult = await this.pay(opts);
-      return this.finalize(payResult, { returnUrl: opts.returnUrl });
-    }
-    /**
-     * Resolve a raw `PayResult` (from any pay endpoint — `pay()`, `payDirect()`,
-     * `processApplePay()`, `offers.payPreviewedOffer()`, …) into a typed
-     * `ProcessPaymentResult` (`succeeded` / `requires_redirect` / `failed`
-     * / `pending`).
-     *
-     * Handles 3DS routing (modal challenge via core-js, or bank redirect)
-     * and async polling until the payment reaches a terminal status.
-     *
-     * This is the same logic `processPayment()` runs after `pay()` — exposed
-     * so callers (and the offers module) that already have a raw `PayResult`
-     * don't need to re-pay.
-     */
-    async finalize(input, opts) {
-      var _a, _b;
-      const payment = input.payment;
-      const returnUrl = (opts == null ? void 0 : opts.returnUrl) ?? (typeof window !== "undefined" ? window.location.href : void 0);
-      if (payment.status === "succeeded") {
-        return { status: "succeeded", payment, order: input.order };
-      }
-      if (payment.status === "failed" || payment.status === "declined") {
-        const msg = ((_a = payment.requireActionData) == null ? void 0 : _a.message) || ((_b = payment.requireActionData) == null ? void 0 : _b.errorCode) || `Payment ${payment.status}`;
-        return { status: "failed", error: msg, payment };
-      }
-      if (payment.requireAction && payment.requireAction !== "none" && payment.requireActionData) {
-        return this.handlePaymentAction(payment, { returnUrl });
-      }
-      return this.pollUntilDone(payment.id);
-    }
-    /**
-     * Resume a payment after the user returns from a redirect (3DS, processor auth, APM).
-     *
-     * Called automatically by `usePayment()` in React when it detects return-URL params.
-     * You can also call it manually in non-React apps.
-     */
-    async resumeAfterRedirect(paymentId) {
-      return this.pollUntilDone(paymentId);
-    }
-    /**
-     * Detect a return from a 3DS / processor redirect by inspecting the
-     * current page URL, then poll the payment to completion.
-     *
-     * The post-3DS URL convention used by Tagada-routed processors is
-     * `?paymentAction=requireAction&paymentActionStatus=completed&paymentId=pay_xxx`.
-     * If those params are present, this method polls the payment, cleans the
-     * URL (so a refresh doesn't re-trigger), and returns the resolved
-     * `ProcessPaymentResult`. Otherwise it returns `null`.
-     *
-     * Use this in vanilla apps as the first thing on page load. The React
-     * `usePayment` hook does the same automatically — don't call this when
-     * also using `usePayment`, you'll double-poll.
-     *
-     * @example
-     * ```ts
-     * const tagada = createHeadlessClient({ storeId, environment });
-     *
-     * const resumed = await tagada.payment.maybeResumeFromUrl();
-     * if (resumed?.status === 'succeeded') {
-     *   window.location.href = `/thank-you?orderId=${resumed.order?.id}`;
-     *   return;
-     * }
-     * if (resumed?.status === 'failed') {
-     *   showError(resumed.error);
-     *   return;
-     * }
-     * // No 3DS return — render the normal page.
-     * ```
-     */
-    async maybeResumeFromUrl(opts) {
-      if (typeof window === "undefined" && !(opts == null ? void 0 : opts.url))
-        return null;
-      const href = (opts == null ? void 0 : opts.url) ?? window.location.href;
-      let url;
-      try {
-        url = new URL(href);
-      } catch {
-        return null;
-      }
-      const action = url.searchParams.get("paymentAction");
-      const actionStatus = url.searchParams.get("paymentActionStatus");
-      const paymentId = url.searchParams.get("paymentId");
-      if (action !== "requireAction" || actionStatus !== "completed" || !paymentId) {
-        return null;
-      }
-      const result = await this.resumeAfterRedirect(paymentId);
-      if ((opts == null ? void 0 : opts.cleanUrl) !== false && typeof window !== "undefined" && !(opts == null ? void 0 : opts.url)) {
-        const cleanParams = new URLSearchParams(window.location.search);
-        [
-          "paymentAction",
-          "paymentActionStatus",
-          "paymentId",
-          "payment_intent",
-          "payment_intent_client_secret",
-          "source_type",
-          "redirect_status",
-          "sessionId"
-        ].forEach((k) => cleanParams.delete(k));
-        const search = cleanParams.toString();
-        try {
-          window.history.replaceState(
-            {},
-            document.title,
-            window.location.pathname + (search ? "?" + search : "")
-          );
-        } catch {
-        }
-      }
-      return result;
-    }
-    // ---------------------------------------------------------------------------
-    // Status polling
-    // ---------------------------------------------------------------------------
-    /** Get current status of a payment. */
-    async getPaymentStatus(paymentId) {
-      return this.http.get(`/api/v1/payments/${paymentId}`);
-    }
-    /**
-     * Poll a payment until it reaches a terminal status.
-     * Returns the final status or throws on timeout.
-     */
-    async pollPaymentStatus(paymentId, opts) {
-      const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
-      const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
-      const start = Date.now();
-      while (Date.now() - start < timeout) {
-        const status = await this.getPaymentStatus(paymentId);
-        if (status.status === "succeeded" || status.status === "failed" || status.status === "declined") {
-          return status;
-        }
-        await new Promise((r) => setTimeout(r, interval));
-      }
-      throw new Error(`Payment ${paymentId} did not reach terminal status within ${timeout}ms.`);
-    }
-    /** Finalize a payment after a 3DS challenge completes. */
-    async completeAfter3ds(paymentId) {
-      return this.http.post("/api/v1/payments/complete-after-3ds", {
-        paymentId
-      });
-    }
-    /** Tell the server this action has been seen / is being processed. */
-    async markActionProcessed(paymentId) {
-      try {
-        await this.http.post("/api/v1/payments/require-action/processed", {
-          paymentId
-        });
-      } catch {
-      }
-    }
-    // ---------------------------------------------------------------------------
-    // Internal: action routing
-    // ---------------------------------------------------------------------------
-    /**
-     * Route a payment action to the appropriate handler.
-     * Returns `requires_redirect` for browser-level redirects,
-     * or attempts 3DS inline and polls to completion.
-     */
-    async handlePaymentAction(payment, opts) {
-      const actionData = payment.requireActionData;
-      await this.markActionProcessed(payment.id);
-      const actionType = actionData.type;
-      switch (actionType) {
-        case "threeds_auth":
-          return this.handleThreedsAuth(payment, opts);
-        case "processor_auth":
-        case "redirect_to_payment":
-          return this.extractRedirect(payment, actionData);
-        case "redirect":
-          return this.extractRedirect(payment, actionData);
-        case "error":
-          return {
-            status: "failed",
-            error: actionData.message || actionData.errorCode || "Payment failed",
-            payment
-          };
-        default:
-          return this.extractRedirect(payment, actionData);
-      }
-    }
-    /**
-     * Extract redirect info from actionData.
-     * Works for processor_auth (GET or POST), redirect, and any unknown type with a URL.
-     */
-    extractRedirect(payment, actionData) {
-      var _a, _b;
-      const redirect = (_a = actionData.metadata) == null ? void 0 : _a.redirect;
-      const url = (redirect == null ? void 0 : redirect.redirectUrl) || actionData.redirectUrl;
-      if (!url) {
-        return {
-          status: "failed",
-          error: `Payment requires action (${actionData.type}) but no redirect URL was provided`,
-          payment
-        };
-      }
-      return {
-        status: "requires_redirect",
-        redirectUrl: url,
-        method: ((_b = redirect == null ? void 0 : redirect.method) == null ? void 0 : _b.toUpperCase()) || "GET",
-        postData: redirect == null ? void 0 : redirect.data,
-        paymentId: payment.id
-      };
-    }
-    /**
-     * Run a 3DS challenge using @tagadapay/core-js.
-     * If core-js is not installed, falls back to redirect.
-     */
-    async handleThreedsAuth(payment, opts) {
-      var _a, _b;
-      const session = (_b = (_a = payment.requireActionData) == null ? void 0 : _a.metadata) == null ? void 0 : _b.threedsSession;
-      if (!(session == null ? void 0 : session.externalSessionId)) {
-        return this.extractRedirect(payment, payment.requireActionData);
-      }
-      let coreJs;
-      try {
-        coreJs = await import("@tagadapay/core-js");
-      } catch {
-        if (session.acsChallengeUrl) {
-          return {
-            status: "requires_redirect",
-            redirectUrl: session.acsChallengeUrl,
-            paymentId: payment.id
-          };
-        }
-        return this.extractRedirect(payment, payment.requireActionData);
-      }
-      try {
-        const manager = new coreJs.ThreedsManager({ provider: "basis_theory" });
-        await manager.initialize({ apiKey: void 0 });
-        await manager.startChallenge({
-          sessionId: session.externalSessionId,
-          acsChallengeUrl: session.acsChallengeUrl,
-          acsTransactionId: session.acsTransID,
-          threeDSVersion: session.messageVersion
-        });
-        await this.completeAfter3ds(payment.id);
-        return this.pollUntilDone(payment.id);
-      } catch {
-        if (session.acsChallengeUrl) {
-          return {
-            status: "requires_redirect",
-            redirectUrl: session.acsChallengeUrl,
-            paymentId: payment.id
-          };
-        }
-        return {
-          status: "failed",
-          error: "3D Secure authentication failed",
-          payment
-        };
-      }
-    }
-    /**
-     * Poll until the payment reaches a terminal status, then return a ProcessPaymentResult.
-     * Also handles new requireAction that may appear during polling.
-     */
-    async pollUntilDone(paymentId, opts) {
-      const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
-      const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
-      const start = Date.now();
-      let consecutiveErrors = 0;
-      while (Date.now() - start < timeout) {
-        let status;
-        try {
-          status = await this.getPaymentStatus(paymentId);
-          consecutiveErrors = 0;
-        } catch {
-          consecutiveErrors++;
-          if (consecutiveErrors >= 3) {
-            return { status: "failed", error: "Payment verification failed due to network errors" };
-          }
-          await new Promise((r) => setTimeout(r, interval));
-          continue;
-        }
-        if (status.status === "succeeded" || status.status === "pending" && status.subStatus === "authorized") {
-          return { status: "succeeded", payment: status, order: status.order };
-        }
-        if (status.status === "failed" || status.status === "declined") {
-          return { status: "failed", error: status.status, payment: status };
-        }
-        if (status.requireAction && status.requireAction !== "none" && status.requireActionData && !status.requireActionData.processed) {
-          return this.handlePaymentAction(
-            status,
-            {}
-          );
-        }
-        await new Promise((r) => setTimeout(r, interval));
-      }
-      return { status: "pending", paymentId };
-    }
-    // ---------------------------------------------------------------------------
-    // Internal helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * Read paymentSetupConfig from the Tagada routing injection.
-     * Only available when running on Tagada infra (not on external hosting like Vercel).
-     */
-    readInjectedStepConfig() {
-      if (typeof window === "undefined")
-        return null;
-      const raw = window.__TGD_STEP_CONFIG__;
-      if (!raw)
-        return null;
-      try {
-        const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
-        return (parsed == null ? void 0 : parsed.paymentSetupConfig) ?? null;
-      } catch {
-        return null;
-      }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async loadCoreJs() {
-      try {
-        return await import("@tagadapay/core-js");
-      } catch {
-        throw new Error(
-          "This method requires @tagadapay/core-js. Install it: npm install @tagadapay/core-js"
-        );
-      }
-    }
-  };
-
-  // src/core/modules/offers.ts
-  var OffersModule = class {
-    constructor(http, storeId, payment) {
-      this.http = http;
-      this.storeId = storeId;
-      this.payment = payment;
-    }
-    // ---------------------------------------------------------------------------
-    // Offer loading
-    // ---------------------------------------------------------------------------
-    /** Get a single offer by ID. */
-    async getOffer(offerId) {
-      return this.http.get(`/api/v1/offers/${offerId}`);
-    }
-    /** List offers for the current store. Optionally filter by type or a set of IDs. */
-    async listOffers(opts) {
-      var _a;
-      let url = `/api/v1/stores/${this.storeId}/offers`;
-      const queryParts = [];
-      if (opts == null ? void 0 : opts.type)
-        queryParts.push(`type=${encodeURIComponent(opts.type)}`);
-      if ((_a = opts == null ? void 0 : opts.ids) == null ? void 0 : _a.length) {
-        for (const id of opts.ids)
-          queryParts.push(`ids=${encodeURIComponent(id)}`);
-      }
-      if (queryParts.length)
-        url += `?${queryParts.join("&")}`;
-      const res = await this.http.get(url);
-      return res.offers ?? [];
-    }
-    // ---------------------------------------------------------------------------
-    // Preview & pay (one-click upsell flow from plugin-sdk)
-    // ---------------------------------------------------------------------------
-    /** Preview offer pricing. Returns line items with amounts and totals. */
-    async previewOffer(opts) {
-      return this.http.post(`/api/v1/offers/${opts.offerId}/preview`, {
-        offerId: opts.offerId,
-        currency: opts.currency ?? "",
-        lineItems: opts.lineItems
-      });
-    }
-    /**
-     * Pay a previously previewed offer (one-click charge).
-     * Used after a main order so the stored payment instrument is reused.
-     *
-     * **Low-level API.** Returns the raw `OfferPayResult` — `requireAction`,
-     * polling, and 3DS redirects are NOT handled. For most cases, use
-     * {@link processOfferPayment} which orchestrates the full lifecycle.
-     */
-    async payPreviewedOffer(opts) {
-      return this.http.post(`/api/v1/offers/${opts.offerId}/pay-preview`, {
-        offerId: opts.offerId,
-        currency: opts.currency ?? "",
-        lineItems: opts.lineItems,
-        returnUrl: opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : ""),
-        mainOrderId: opts.mainOrderId,
-        paymentInstrumentId: opts.paymentInstrumentId
-      });
-    }
-    /**
-     * One-click upsell with full lifecycle handling.
-     *
-     * Like `payment.processPayment()` but for previewed offers: charges the
-     * stored instrument from `mainOrderId`, runs any 3DS challenge or bank
-     * redirect, polls until terminal, and returns a typed
-     * `ProcessPaymentResult` (`succeeded` / `requires_redirect` /
-     * `failed` / `pending`).
-     *
-     * Use this instead of the lower-level `payPreviewedOffer()` whenever you
-     * don't need to inspect the raw `OfferPayResult` shape — which is most
-     * of the time.
-     *
-     * @example
-     * ```ts
-     * const result = await tagada.offers.processOfferPayment({
-     *   offerId: 'offer_xxx',
-     *   mainOrderId: order.id,
-     *   returnUrl: window.location.href,
-     * });
-     *
-     * switch (result.status) {
-     *   case 'succeeded':
-     *     window.location.href = '/upsell-2';
-     *     break;
-     *   case 'requires_redirect':
-     *     window.location.href = result.redirectUrl;
-     *     break;
-     *   case 'failed':
-     *     showError(result.error);
-     *     break;
-     * }
-     * ```
-     */
-    async processOfferPayment(opts) {
-      if (!this.payment) {
-        throw new Error(
-          "OffersModule: no PaymentModule injected. Use createHeadlessClient() instead of constructing OffersModule directly."
-        );
-      }
-      const returnUrl = opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : void 0);
-      const payResult = await this.payPreviewedOffer({ ...opts, returnUrl });
-      return this.payment.finalize(
-        { payment: payResult.payment, order: payResult.order },
-        { returnUrl }
-      );
-    }
-    // ---------------------------------------------------------------------------
-    // Order bumps (checkout-session scoped)
-    // ---------------------------------------------------------------------------
-    /** Toggle an order bump on/off within a checkout session. */
-    async toggleOrderBump(opts) {
-      return this.http.post(
-        `/api/v1/checkout-sessions/${opts.checkoutSessionId}/toggle-order-bump`,
-        {
-          orderBumpOfferId: opts.orderBumpOfferId,
-          selected: opts.selected
-        }
-      );
-    }
-    // ---------------------------------------------------------------------------
-    // Post-purchase offers (order-scoped)
-    // ---------------------------------------------------------------------------
-    /** List post-purchase offers for an order. */
-    async listPostPurchaseOffers(orderId) {
-      const res = await this.http.get(`/api/v1/post-purchase/${orderId}/offers`);
-      return Array.isArray(res) ? res : [];
-    }
-    /** Accept a post-purchase offer. */
-    async acceptPostPurchaseOffer(opts) {
-      return this.http.post(
-        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/accept`,
-        { items: opts.items ?? [] }
-      );
-    }
-    /** Decline a post-purchase offer. */
-    async declinePostPurchaseOffer(opts) {
-      return this.http.post(
-        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/decline`
-      );
-    }
-  };
-
-  // src/core/modules/customer.ts
-  var CustomerModule = class {
-    constructor(http, storeId) {
-      this.http = http;
-      this.storeId = storeId;
-    }
-    /** Get customer profile by ID. */
-    async getProfile(customerId) {
-      const res = await this.http.get(
-        `/api/v1/customers/${customerId}`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.customer;
-    }
-    /** Get customer profile by email. */
-    async getByEmail(email) {
-      try {
-        const res = await this.http.get(
-          "/api/v1/customers/by-email",
-          { params: { email, storeId: this.storeId } }
-        );
-        return res.customer;
-      } catch {
-        return null;
-      }
-    }
-    /** Update customer profile fields. */
-    async updateProfile(customerId, data) {
-      const res = await this.http.patch(
-        `/api/v1/customers/${customerId}`,
-        { storeId: this.storeId, ...data }
-      );
-      return res.customer;
-    }
-    /** List orders for a customer. */
-    async getOrders(customerId, opts) {
-      return this.http.get(
-        `/api/v1/customers/${customerId}/orders`,
-        { params: { storeId: this.storeId, limit: opts == null ? void 0 : opts.limit, offset: opts == null ? void 0 : opts.offset } }
-      );
-    }
-    /** Get a single order by ID. */
-    async getOrder(orderId) {
-      const res = await this.http.get(`/api/v1/orders/${orderId}`, {
-        params: { storeId: this.storeId }
-      });
-      return res.order;
-    }
-    /** List subscriptions for a customer. */
-    async getSubscriptions(customerId) {
-      const res = await this.http.get(
-        `/api/v1/customers/${customerId}/subscriptions`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.subscriptions;
-    }
-    /** Get a single subscription by ID. */
-    async getSubscription(subscriptionId) {
-      const res = await this.http.get(
-        `/api/v1/subscriptions/${subscriptionId}`,
-        { params: { storeId: this.storeId } }
-      );
-      return res.subscription;
-    }
-  };
-
-  // src/core/modules/catalog.ts
-  var CatalogModule = class {
-    constructor(http, storeId) {
-      this.http = http;
-      this.storeId = storeId;
-    }
-    /**
-     * List all active products for the store, including variants and prices.
-     *
-     * @param opts.productIds  Optional filter to specific product IDs.
-     * @param opts.variantIds  Optional filter to products containing these variant IDs.
-     */
-    async getProducts(opts) {
-      var _a, _b;
-      const body = {
-        storeId: this.storeId,
-        includeVariants: true,
-        includePrices: true
-      };
-      if ((_a = opts == null ? void 0 : opts.productIds) == null ? void 0 : _a.length)
-        body.productIds = opts.productIds;
-      if ((_b = opts == null ? void 0 : opts.variantIds) == null ? void 0 : _b.length)
-        body.variantIds = opts.variantIds;
-      const res = await this.http.post(
-        "/api/v1/products",
-        body
-      );
-      return res.items ?? [];
-    }
-    /**
-     * Get a single product by ID.
-     */
-    async getProduct(productId) {
-      const items = await this.getProducts({ productIds: [productId] });
-      return items[0] ?? null;
-    }
-  };
-
-  // src/core/modules/funnel.ts
-  var FunnelModule = class {
-    constructor(http, storeId, checkout, accountId) {
-      this.http = http;
-      this.storeId = storeId;
-      this.checkout = checkout;
-      this.accountId = accountId;
-    }
-    async navigate(input) {
-      var _a;
-      const session = this.checkout.getCurrentSession();
-      if (!session) {
-        throw new TagadaError(
-          "No checkout session loaded. Call sdk.checkout.loadSession(...) before sdk.funnel.navigate(...).",
-          "no_cart_loaded"
-        );
-      }
-      const accountId = input.accountId ?? this.accountId;
-      if (!accountId) {
-        throw new TagadaError(
-          "accountId is required for funnel.navigate(). Set it on createHeadlessClient({ accountId }) or pass it per call.",
-          "missing_account_id"
-        );
-      }
-      const currentUrl = input.currentUrl ?? (typeof globalThis !== "undefined" ? (_a = globalThis.location) == null ? void 0 : _a.href : void 0);
-      await this.ensureCmsSession(session, accountId, input);
-      const funnelSessionId = await this.initializeFunnel({
-        funnelId: input.funnelId,
-        stepId: input.stepId,
-        accountId,
-        currentUrl
-      });
-      const url = await this.runNavigate({
-        funnelSessionId,
-        stepId: input.stepId,
-        session,
-        input,
-        currentUrl
-      });
-      return { url, funnelSessionId };
-    }
-    // -------------------------------------------------------------------------
-    // Internals
-    // -------------------------------------------------------------------------
-    async ensureCmsSession(session, accountId, input) {
-      var _a, _b, _c;
-      if (this._cmsToken && this._cmsSessionId && this._cmsCustomerId)
-        return;
-      const anon = await this.http.post(
-        "/api/v1/cms/session/anonymous",
-        { storeId: this.storeId, role: "anonymous", draft: false }
-      );
-      this._cmsToken = anon.token;
-      this._cmsSessionId = anon.sessionId;
-      const init = await this.http.post(
-        "/api/v1/cms/session/v2/init",
-        {
-          storeId: this.storeId,
-          accountId,
-          customerId: "anon_placeholder",
-          browserLocale: ((_a = input.customer) == null ? void 0 : _a.locale) ?? defaultLocale(),
-          userAgent: defaultUserAgent(),
-          queryCurrency: ((_b = input.customer) == null ? void 0 : _b.currency) ?? session.currency,
-          queryLocale: (_c = input.customer) == null ? void 0 : _c.locale
-        },
-        { token: this._cmsToken }
-      );
-      this._cmsCustomerId = init.customer.id;
-    }
-    async initializeFunnel(args) {
-      const res = await this.http.post(
-        "/api/v1/funnel/initialize",
-        {
-          cmsSession: {
-            customerId: this._cmsCustomerId,
-            sessionId: this._cmsSessionId,
-            storeId: this.storeId,
-            accountId: args.accountId
-          },
-          funnelId: args.funnelId,
-          entryStepId: args.stepId,
-          funnelStepId: args.stepId,
-          currentUrl: args.currentUrl,
-          draft: false
-        },
-        { token: this._cmsToken }
-      );
-      return res.context.sessionId;
-    }
-    async runNavigate(args) {
-      var _a, _b, _c, _d;
-      const { funnelSessionId, stepId, session, input, currentUrl } = args;
-      const lineItems = session.items.map((i) => ({
-        variantId: i.variantId,
-        priceId: i.priceId,
-        quantity: i.quantity
-      }));
-      const discountCodes = input.discountCodes ?? (session.promotionCode ? [session.promotionCode] : void 0);
-      const customer = {
-        email: ((_a = input.customer) == null ? void 0 : _a.email) ?? ((_b = session.customer) == null ? void 0 : _b.email),
-        currency: ((_c = input.customer) == null ? void 0 : _c.currency) ?? session.currency,
-        locale: (_d = input.customer) == null ? void 0 : _d.locale
-      };
-      const res = await this.http.post(
-        "/api/v1/funnel/navigate",
-        {
-          sessionId: funnelSessionId,
-          currentUrl,
-          funnelStepId: stepId,
-          fireAndForget: false,
-          event: {
-            type: "INIT_CHECKOUT",
-            data: {
-              checkoutInit: {
-                cartToken: session.id,
-                lineItems,
-                customer,
-                returnUrl: input.returnUrl,
-                storeId: this.storeId,
-                metadata: input.metadata,
-                discountCodes
-              }
-            }
-          }
-        },
-        { token: this._cmsToken }
-      );
-      return res.result.url;
-    }
-  };
-  function defaultLocale() {
-    if (typeof navigator !== "undefined" && navigator.language)
-      return navigator.language;
-    return "en-US";
-  }
-  function defaultUserAgent() {
-    if (typeof navigator !== "undefined" && navigator.userAgent)
-      return navigator.userAgent;
-    return "tagadapay-headless-sdk";
-  }
-
-  // src/core/client.ts
-  var HeadlessClient = class {
-    constructor(config) {
-      const environment = config.environment ?? "production";
-      const baseUrl = HttpClient.resolveBaseUrl(environment, config.baseUrl);
-      this.config = {
-        ...config,
-        environment,
-        baseUrl,
-        timeout: config.timeout ?? 3e4
-      };
-      this.http = new HttpClient({
-        baseUrl,
-        timeout: this.config.timeout,
-        apiKey: config.apiKey,
-        getToken: () => this._sessionToken
-      });
-      const setToken = (token) => {
-        this._sessionToken = token;
-      };
-      this.checkout = new CheckoutModule(this.http, this.config.storeId, setToken);
-      this.payment = new PaymentModule(this.http, this.config.storeId, environment);
-      this.offers = new OffersModule(this.http, this.config.storeId, this.payment);
-      this.customer = new CustomerModule(this.http, this.config.storeId);
-      this.catalog = new CatalogModule(this.http, this.config.storeId);
-      this.funnel = new FunnelModule(
-        this.http,
-        this.config.storeId,
-        this.checkout,
-        this.config.accountId
-      );
-    }
-    /** Manually set the session token (e.g. from URL params on page load). */
-    setSessionToken(token) {
-      this._sessionToken = token;
-    }
-  };
-  function createHeadlessClient(config) {
-    return new HeadlessClient(config);
-  }
-
-  // src/core/helpers/autocomplete.ts
-  var scriptInjected = false;
-  var scriptReady = false;
-  var readyCallbacks = [];
-  function onScriptReady() {
-    scriptReady = true;
-    for (const cb of readyCallbacks)
-      cb();
-    readyCallbacks.length = 0;
-  }
-  function loadGoogleMapsScript(apiKey, opts = {}) {
-    var _a, _b;
-    if (scriptReady || ((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
-      onScriptReady();
-      return Promise.resolve();
-    }
-    if (scriptInjected) {
-      return new Promise((resolve) => readyCallbacks.push(resolve));
-    }
-    scriptInjected = true;
-    return new Promise((resolve, reject) => {
-      readyCallbacks.push(resolve);
-      const existing = document.querySelector('script[src*="maps.googleapis.com"]');
-      if (existing) {
-        const poll = () => {
-          var _a2, _b2;
-          if ((_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) {
-            onScriptReady();
-          } else {
-            setTimeout(poll, 100);
-          }
-        };
-        poll();
-        return;
-      }
-      const params = new URLSearchParams({
-        key: apiKey,
-        libraries: "places",
-        v: opts.version ?? "weekly"
-      });
-      if (opts.language)
-        params.set("language", opts.language);
-      if (opts.region)
-        params.set("region", opts.region);
-      const script = document.createElement("script");
-      script.src = `https://maps.googleapis.com/maps/api/js?${params}`;
-      script.async = true;
-      script.defer = true;
-      script.onload = () => onScriptReady();
-      script.onerror = () => reject(new Error("Failed to load Google Maps script"));
-      document.head.appendChild(script);
-    });
-  }
-  var GoogleAutocompleteCore = class _GoogleAutocompleteCore {
-    /** Search for address predictions. */
-    static async searchPlaces(input, options = {}) {
-      var _a, _b;
-      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places) || !input.trim())
-        return [];
-      const service = new window.google.maps.places.AutocompleteService();
-      return new Promise((resolve) => {
-        service.getPlacePredictions(
-          { input, types: options.types ?? ["address"], componentRestrictions: options.componentRestrictions },
-          (predictions, status) => {
-            var _a2, _b2, _c;
-            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && predictions ? predictions : []);
-          }
-        );
-      });
-    }
-    /** Get full place details by place_id. */
-    static async getPlaceDetails(placeId) {
-      var _a, _b;
-      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places))
-        return null;
-      const svc = new window.google.maps.places.PlacesService(document.createElement("div"));
-      return new Promise((resolve) => {
-        svc.getDetails(
-          { placeId, fields: ["place_id", "formatted_address", "address_components", "geometry"] },
-          (place, status) => {
-            var _a2, _b2, _c;
-            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && place ? place : null);
-          }
-        );
-      });
-    }
-    /** Extract structured address fields from a Google PlaceDetails result. */
-    static extractAddressComponents(place) {
-      const out = {
-        subpremise: "",
-        streetNumber: "",
-        route: "",
-        locality: "",
-        administrativeAreaLevel1: "",
-        administrativeAreaLevel1Long: "",
-        administrativeAreaLevel2: "",
-        administrativeAreaLevel2Long: "",
-        country: "",
-        postalCode: "",
-        fullStreetAddress: ""
-      };
-      let premise = "";
-      let neighborhood = "";
-      let sublocality5 = "", sublocality4 = "", sublocality3 = "", sublocality2 = "", sublocality1 = "";
-      let postalTown = "";
-      for (const c of place.address_components ?? []) {
-        const t = c.types;
-        if (t.includes("subpremise"))
-          out.subpremise = c.long_name;
-        if (t.includes("street_number"))
-          out.streetNumber = c.long_name;
-        if (t.includes("premise"))
-          premise = c.long_name;
-        if (t.includes("route"))
-          out.route = c.long_name;
-        if (t.includes("neighborhood"))
-          neighborhood = c.long_name;
-        if (t.includes("sublocality_level_5"))
-          sublocality5 = c.long_name;
-        if (t.includes("sublocality_level_4"))
-          sublocality4 = c.long_name;
-        if (t.includes("sublocality_level_3"))
-          sublocality3 = c.long_name;
-        if (t.includes("sublocality_level_2"))
-          sublocality2 = c.long_name;
-        if (t.includes("sublocality_level_1"))
-          sublocality1 = c.long_name;
-        if (t.includes("locality"))
-          out.locality = c.long_name;
-        if (t.includes("postal_town"))
-          postalTown = c.long_name;
-        if (t.includes("administrative_area_level_2")) {
-          out.administrativeAreaLevel2 = c.short_name;
-          out.administrativeAreaLevel2Long = c.long_name;
-        }
-        if (t.includes("administrative_area_level_1")) {
-          out.administrativeAreaLevel1 = c.short_name;
-          out.administrativeAreaLevel1Long = c.long_name;
-        }
-        if (t.includes("country"))
-          out.country = c.short_name;
-        if (t.includes("postal_code"))
-          out.postalCode = c.long_name;
-      }
-      if (!out.locality)
-        out.locality = postalTown || sublocality2 || sublocality1 || "";
-      if (!out.administrativeAreaLevel1 && out.administrativeAreaLevel2) {
-        out.administrativeAreaLevel1 = out.administrativeAreaLevel2Long || out.administrativeAreaLevel2;
-        out.administrativeAreaLevel1Long = out.administrativeAreaLevel2Long;
-      }
-      const buildingNumber = out.streetNumber || premise;
-      const streetName = out.route || sublocality5 || sublocality4 || sublocality3 || neighborhood;
-      if (out.subpremise && buildingNumber && streetName) {
-        out.fullStreetAddress = `${out.subpremise}/${buildingNumber} ${streetName}`;
-      } else if (buildingNumber && streetName) {
-        if (premise && sublocality4 && sublocality3) {
-          let addr = `${sublocality3}-${sublocality4}-${premise}`;
-          if (sublocality2)
-            addr = `${addr} ${sublocality2}`;
-          out.fullStreetAddress = addr;
-        } else {
-          out.fullStreetAddress = `${buildingNumber} ${streetName}`;
-        }
-      } else if (streetName) {
-        out.fullStreetAddress = streetName;
-      } else if (buildingNumber) {
-        out.fullStreetAddress = buildingNumber;
-      }
-      out.fullStreetAddress = out.fullStreetAddress.trim();
-      return out;
-    }
-    /** Shorthand: extract into the flat shape used by address forms. */
-    static extractFormattedAddress(place) {
-      const a = _GoogleAutocompleteCore.extractAddressComponents(place);
-      return {
-        address1: a.fullStreetAddress,
-        city: a.locality,
-        country: a.country,
-        state: a.administrativeAreaLevel1,
-        postal: a.postalCode
-      };
-    }
-  };
-
-  // src/core/helpers/iso3166.ts
-  var GEODATA_CDN_BASE = "https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1";
-  var AVAILABLE_LANGUAGES = ["en", "ru", "de", "da", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
-  var countriesCache = /* @__PURE__ */ new Map();
-  var regionsCache = /* @__PURE__ */ new Map();
-  var inflightCountries = /* @__PURE__ */ new Map();
-  var inflightRegions = /* @__PURE__ */ new Map();
-  async function fetchCountriesRaw(language) {
-    const cached = countriesCache.get(language);
-    if (cached)
-      return cached;
-    let inflight = inflightCountries.get(language);
-    if (inflight)
-      return inflight;
-    inflight = (async () => {
-      const url = `${GEODATA_CDN_BASE}/${language}/countries.json`;
-      const res = await fetch(url);
-      if (!res.ok)
-        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
-      const data = await res.json();
-      countriesCache.set(language, data);
-      inflightCountries.delete(language);
-      return data;
-    })();
-    inflightCountries.set(language, inflight);
-    return inflight;
-  }
-  async function fetchRegionsRaw(language) {
-    const cached = regionsCache.get(language);
-    if (cached)
-      return cached;
-    let inflight = inflightRegions.get(language);
-    if (inflight)
-      return inflight;
-    inflight = (async () => {
-      const url = `${GEODATA_CDN_BASE}/${language}/regions.json`;
-      const res = await fetch(url);
-      if (!res.ok)
-        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
-      const data = await res.json();
-      regionsCache.set(language, data);
-      inflightRegions.delete(language);
-      return data;
-    })();
-    inflightRegions.set(language, inflight);
-    return inflight;
-  }
-  function getCountriesCached(language) {
-    return countriesCache.get(language) || countriesCache.get("en") || {};
-  }
-  function getRegionsCached(language) {
-    return regionsCache.get(language) || regionsCache.get("en") || {};
-  }
-  async function ensureGeoDataLoaded(language = "en") {
-    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
-  }
-  var getCountries = (language = "en") => {
-    const raw = getCountriesCached(language);
-    return Object.entries(raw).map(([code, c]) => ({ code, name: c.n, iso3: c.i3, numeric: c.nu })).sort((a, b) => a.name.localeCompare(b.name));
-  };
-  var getStatesForCountry = (countryCode, language = "en") => {
-    const raw = getRegionsCached(language);
-    const tuples = raw[countryCode];
-    if (!tuples)
-      return [];
-    return tuples.map(([iso, name]) => ({ code: iso, name, countryCode })).sort((a, b) => a.name.localeCompare(b.name));
-  };
-  function isLanguageLoaded(language) {
-    return countriesCache.has(language);
-  }
-
-  // src/core/helpers/countries.ts
-  var ISODataCore = class _ISODataCore {
-    /** Fetch countries + regions from CDN for a language. Call before sync getters. */
-    static ensureLoaded(language = "en") {
-      return ensureGeoDataLoaded(language);
-    }
-    /** Get all countries as a Record keyed by ISO code. */
-    static getCountries(language = "en") {
-      const arr = getCountries(language);
-      const result = {};
-      for (const c of arr) {
-        result[c.code] = { iso: c.code, iso3: c.iso3 ?? "", numeric: c.numeric ?? 0, name: c.name };
-      }
-      return result;
-    }
-    /** Get all countries as a sorted array of { value, label } for select inputs. */
-    static getCountryOptions(language = "en") {
-      return getCountries(language).map((c) => ({ value: c.code, label: c.name }));
-    }
-    /** Get regions/states for a country. */
-    static getRegions(countryCode, language = "en") {
-      return getStatesForCountry(countryCode, language).map((s) => ({ iso: s.code, name: s.name }));
-    }
-    /** Get regions as a sorted array of { value, label } for select inputs. */
-    static getRegionOptions(countryCode, language = "en") {
-      return _ISODataCore.getRegions(countryCode, language).map((r) => ({ value: r.iso, label: r.name }));
-    }
-    /** Find a specific region by ISO code. */
-    static findRegion(countryCode, regionCode, language = "en") {
-      return _ISODataCore.getRegions(countryCode, language).find((r) => r.iso === regionCode) ?? null;
-    }
-    /**
-     * Map a Google Places administrative_area to an ISO region.
-     * Tries exact ISO match, then name match, then partial match.
-     */
-    static mapGoogleToISO(googleState, googleStateLong, countryCode, language = "en") {
-      const regions = _ISODataCore.getRegions(countryCode, language);
-      if (regions.length === 0)
-        return null;
-      let match = regions.find((r) => r.iso === googleState);
-      if (match)
-        return match;
-      match = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
-      if (match)
-        return match;
-      match = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
-      if (match)
-        return match;
-      match = regions.find(
-        (r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) || googleStateLong.toLowerCase().includes(r.name.toLowerCase())
-      );
-      return match ?? null;
-    }
-    static isLanguageLoaded(language) {
-      return isLanguageLoaded(language);
-    }
-    static getAvailableLanguages() {
-      return AVAILABLE_LANGUAGES;
-    }
-  };
-
-  // src/core/helpers/currency.ts
-  var SYMBOLS = {
-    USD: "$",
-    EUR: "\u20AC",
-    GBP: "\xA3",
-    JPY: "\xA5",
-    CAD: "C$",
-    AUD: "A$",
-    CHF: "CHF",
-    CNY: "\xA5",
-    SEK: "kr",
-    NOK: "kr",
-    DKK: "kr",
-    PLN: "z\u0142",
-    CZK: "K\u010D",
-    HUF: "Ft",
-    RON: "lei",
-    BGN: "\u043B\u0432",
-    HRK: "kn",
-    RUB: "\u20BD",
-    UAH: "\u20B4",
-    TRY: "\u20BA",
-    BRL: "R$",
-    MXN: "$",
-    ZAR: "R",
-    INR: "\u20B9",
-    KRW: "\u20A9",
-    THB: "\u0E3F",
-    VND: "\u20AB",
-    IDR: "Rp",
-    MYR: "RM",
-    SGD: "S$",
-    PHP: "\u20B1",
-    TWD: "NT$",
-    HKD: "HK$",
-    ILS: "\u20AA",
-    AED: "\u062F.\u0625",
-    SAR: "\u0631.\u0633",
-    QAR: "\u0631.\u0642",
-    KWD: "\u062F.\u0643",
-    BHD: "\u062F.\u0628",
-    OMR: "\u0631.\u0639.",
-    EGP: "\xA3",
-    NGN: "\u20A6",
-    KES: "KSh",
-    GHS: "\u20B5",
-    COP: "$",
-    ARS: "$",
-    CLP: "$",
-    PEN: "S/",
-    CRC: "\u20A1",
-    DOP: "RD$",
-    JMD: "J$",
-    BOB: "Bs",
-    PYG: "\u20B2",
-    GTQ: "Q",
-    NIO: "C$",
-    PAB: "B/.",
-    PKR: "\u20A8",
-    BDT: "\u09F3",
-    LKR: "\u20A8",
-    NPR: "\u20A8",
-    GEL: "\u20BE",
-    AMD: "\u058F",
-    AZN: "\u20BC",
-    KZT: "\u20B8"
-  };
-  var NAMES = {
-    USD: "US Dollar",
-    EUR: "Euro",
-    GBP: "British Pound",
-    JPY: "Japanese Yen",
-    CAD: "Canadian Dollar",
-    AUD: "Australian Dollar",
-    CHF: "Swiss Franc",
-    CNY: "Chinese Yuan",
-    SEK: "Swedish Krona",
-    NOK: "Norwegian Krone",
-    DKK: "Danish Krone",
-    PLN: "Polish Zloty",
-    CZK: "Czech Koruna",
-    HUF: "Hungarian Forint",
-    BRL: "Brazilian Real",
-    MXN: "Mexican Peso",
-    INR: "Indian Rupee",
-    KRW: "South Korean Won",
-    THB: "Thai Baht",
-    SGD: "Singapore Dollar",
-    HKD: "Hong Kong Dollar",
-    TWD: "Taiwan Dollar",
-    ILS: "Israeli Shekel",
-    AED: "UAE Dirham",
-    SAR: "Saudi Riyal",
-    ZAR: "South African Rand",
-    TRY: "Turkish Lira",
-    RUB: "Russian Ruble",
-    NGN: "Nigerian Naira"
-  };
-  var ZERO_DECIMAL = /* @__PURE__ */ new Set([
-    "JPY",
-    "KRW",
-    "VND",
-    "IDR",
-    "LAK",
-    "KHR",
-    "MMK",
-    "PYG"
-  ]);
-  var CurrencyUtils = class _CurrencyUtils {
-    static getSymbol(code) {
-      return SYMBOLS[code] ?? code;
-    }
-    static getName(code) {
-      return NAMES[code] ?? code;
-    }
-    static getDecimalPlaces(code) {
-      return ZERO_DECIMAL.has(code) ? 0 : 2;
-    }
-    static getCurrency(code) {
-      return {
-        code,
-        symbol: _CurrencyUtils.getSymbol(code),
-        name: _CurrencyUtils.getName(code),
-        decimalPlaces: _CurrencyUtils.getDecimalPlaces(code)
-      };
-    }
-  };
-  function formatMoney(amountMinorUnits, currencyCode = "USD", locale = "en-US") {
-    const decimals = CurrencyUtils.getDecimalPlaces(currencyCode);
-    const value = amountMinorUnits / (decimals === 0 ? 100 : Math.pow(10, decimals));
-    try {
-      return new Intl.NumberFormat(locale, {
-        style: "currency",
-        currency: currencyCode,
-        minimumFractionDigits: decimals,
-        maximumFractionDigits: decimals
-      }).format(value);
-    } catch {
-      return `${CurrencyUtils.getSymbol(currencyCode)}${value.toFixed(decimals)}`;
-    }
-  }
-  return __toCommonJS(core_exports);
-})();
-if(typeof window!=="undefined"&&TagadaHeadlessBundle){  window.TagadaHeadless=TagadaHeadlessBundle;  window.TagadaHeadless.create=TagadaHeadlessBundle.createHeadlessClient;}