@funnelfox/billing 0.5.7 → 0.5.8

package/dist/funnelfox-billing.esm.js

@@ -5,1923 +5,4 @@
  * @author Funnelfox
  * @license MIT
  */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * @fileoverview Lightweight event emitter for Funnefox SDK
- */
-class EventEmitter {
-    constructor() {
-        this._events = new Map();
-    }
-    on(eventName, handler) {
-        if (typeof handler !== 'function') {
-            throw new Error('Event handler must be a function');
-        }
-        if (!this._events.has(eventName)) {
-            this._events.set(eventName, []);
-        }
-        this._events.get(eventName).push(handler);
-        return this;
-    }
-    once(eventName, handler) {
-        if (typeof handler !== 'function') {
-            throw new Error('Event handler must be a function');
-        }
-        const onceWrapper = (...args) => {
-            this.off(eventName, onceWrapper);
-            handler.apply(this, args);
-        };
-        return this.on(eventName, onceWrapper);
-    }
-    off(eventName, handler = null) {
-        if (!this._events.has(eventName)) {
-            return this;
-        }
-        if (handler === null) {
-            this._events.delete(eventName);
-            return this;
-        }
-        const handlers = this._events.get(eventName);
-        const index = handlers.indexOf(handler);
-        if (index !== -1) {
-            handlers.splice(index, 1);
-            if (handlers.length === 0) {
-                this._events.delete(eventName);
-            }
-        }
-        return this;
-    }
-    emit(eventName, ...args) {
-        if (!this._events.has(eventName)) {
-            return false;
-        }
-        const handlers = this._events.get(eventName).slice();
-        for (const handler of handlers) {
-            try {
-                handler.apply(this, args);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.warn(`Error in event handler for "${String(eventName)}":`, error);
-            }
-        }
-        return true;
-    }
-    listenerCount(eventName) {
-        return this._events.has(eventName)
-            ? this._events.get(eventName).length
-            : 0;
-    }
-    eventNames() {
-        return Array.from(this._events.keys());
-    }
-    removeAllListeners() {
-        this._events.clear();
-        return this;
-    }
-    listeners(eventName) {
-        return this._events.has(eventName)
-            ? this._events.get(eventName).slice()
-            : [];
-    }
-}
-
-/**
- * @fileoverview Custom error classes for Funnefox SDK
- */
-class FunnefoxSDKError extends Error {
-    constructor(message, code = ERROR_CODES.SDK_ERROR, details = null) {
-        super(message);
-        this.name = 'FunnefoxSDKError';
-        this.code = code;
-        this.details = details;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, FunnefoxSDKError);
-        }
-    }
-}
-class ValidationError extends FunnefoxSDKError {
-    constructor(field, message, value = null) {
-        super(`Invalid ${field}: ${message}`, ERROR_CODES.VALIDATION_ERROR);
-        this.name = 'ValidationError';
-        this.field = field;
-        this.value = value;
-    }
-}
-class APIError extends FunnefoxSDKError {
-    constructor(message, statusCode = null, options = {}) {
-        super(message, options.errorCode || ERROR_CODES.API_ERROR);
-        this.name = 'APIError';
-        this.statusCode = statusCode;
-        this.errorCode = options.errorCode || null;
-        this.errorType = options.errorType || null;
-        this.requestId = options.requestId || null;
-        this.response = options.response || null;
-    }
-}
-class PrimerError extends FunnefoxSDKError {
-    constructor(message, primerError = null) {
-        super(message, ERROR_CODES.PRIMER_ERROR);
-        this.name = 'PrimerError';
-        this.primerError = primerError;
-    }
-}
-class CheckoutError extends FunnefoxSDKError {
-    constructor(message, phase = null) {
-        super(message, ERROR_CODES.CHECKOUT_ERROR);
-        this.name = 'CheckoutError';
-        this.phase = phase;
-    }
-}
-class ConfigurationError extends FunnefoxSDKError {
-    constructor(message) {
-        super(message, ERROR_CODES.CONFIGURATION_ERROR);
-        this.name = 'ConfigurationError';
-    }
-}
-class NetworkError extends FunnefoxSDKError {
-    constructor(message, originalError = null) {
-        super(message, ERROR_CODES.NETWORK_ERROR);
-        this.name = 'NetworkError';
-        this.originalError = originalError;
-    }
-}
-
-/**
- * @fileoverview Dynamic loader for Primer SDK
- * Loads Primer script and CSS from CDN independently of bundler
- */
-const PRIMER_CDN_BASE = 'https://sdk.primer.io/web';
-const DEFAULT_VERSION = '2.57.3';
-// Integrity hashes for specific versions (for SRI security)
-const INTEGRITY_HASHES = {
-    '2.57.3': {
-        js: 'sha384-xq2SWkYvTlKOMpuXQUXq1QI3eZN7JiqQ3Sc72U9wY1IE30MW3HkwQWg/1n6BTMz4',
-    },
-};
-let loadingPromise = null;
-let isLoaded = false;
-/**
- * Injects a script tag into the document head
- */
-function injectScript$1(src, integrity) {
-    return new Promise((resolve, reject) => {
-        // Check if script already exists
-        const existingScript = document.querySelector(`script[src="${src}"]`);
-        if (existingScript) {
-            resolve(existingScript);
-            return;
-        }
-        const script = document.createElement('script');
-        script.src = src;
-        script.async = true;
-        script.crossOrigin = 'anonymous';
-        if (integrity) {
-            script.integrity = integrity;
-        }
-        script.onload = () => resolve(script);
-        script.onerror = () => reject(new Error(`Failed to load Primer SDK script from ${src}`));
-        document.head.appendChild(script);
-    });
-}
-/**
- * Injects a CSS link tag into the document head
- */
-function injectCSS(href, integrity) {
-    return new Promise((resolve, reject) => {
-        // Check if stylesheet already exists
-        const existingLink = document.querySelector(`link[href="${href}"]`);
-        if (existingLink) {
-            resolve(existingLink);
-            return;
-        }
-        const link = document.createElement('link');
-        link.rel = 'stylesheet';
-        link.href = href;
-        link.crossOrigin = 'anonymous';
-        if (integrity) {
-            link.integrity = integrity;
-        }
-        link.onload = () => resolve(link);
-        link.onerror = () => reject(new Error(`Failed to load Primer SDK CSS from ${href}`));
-        document.head.appendChild(link);
-    });
-}
-/**
- * Waits for window.Primer to be available
- */
-function waitForPrimer(timeout = 10000) {
-    return new Promise((resolve, reject) => {
-        const startTime = Date.now();
-        const check = () => {
-            if (typeof window !== 'undefined' &&
-                window.Primer &&
-                typeof window.Primer.createHeadless === 'function') {
-                resolve();
-                return;
-            }
-            if (Date.now() - startTime > timeout) {
-                reject(new Error('Timeout waiting for Primer SDK to initialize on window'));
-                return;
-            }
-            setTimeout(check, 50);
-        };
-        check();
-    });
-}
-/**
- * Loads the Primer SDK script and CSS from CDN
- * @param version - The version of Primer SDK to load (default: 2.57.3)
- * @returns Promise that resolves when SDK is loaded and ready
- */
-async function loadPrimerSDK(version) {
-    // Already loaded
-    if (isLoaded) {
-        return;
-    }
-    // Already loading - return existing promise
-    if (loadingPromise) {
-        return loadingPromise;
-    }
-    // Check if Primer is already available (user may have loaded it manually)
-    if (typeof window !== 'undefined' &&
-        window.Primer &&
-        typeof window.Primer.createHeadless === 'function') {
-        isLoaded = true;
-        return;
-    }
-    const ver = version || DEFAULT_VERSION;
-    const jsUrl = `${PRIMER_CDN_BASE}/v${ver}/Primer.min.js`;
-    const cssUrl = `${PRIMER_CDN_BASE}/v${ver}/Checkout.css`;
-    const hashes = INTEGRITY_HASHES[ver];
-    loadingPromise = (async () => {
-        try {
-            // Load CSS and JS in parallel
-            await Promise.all([
-                injectCSS(cssUrl, hashes?.css),
-                injectScript$1(jsUrl, hashes?.js),
-            ]);
-            // Wait for Primer to be available on window
-            await waitForPrimer();
-            isLoaded = true;
-        }
-        catch (error) {
-            loadingPromise = null;
-            throw error;
-        }
-    })();
-    return loadingPromise;
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * @fileoverview Helper utilities for Funnefox SDK
- */
-function merge(...objects) {
-    const result = {};
-    for (const obj of objects) {
-        if (obj && typeof obj === 'object') {
-            for (const key in obj) {
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    if (typeof obj[key] === 'object' &&
-                        !Array.isArray(obj[key]) &&
-                        obj[key] !== null) {
-                        result[key] = merge(result[key] || {}, obj[key]);
-                    }
-                    else {
-                        result[key] = obj[key];
-                    }
-                }
-            }
-        }
-    }
-    return result;
-}
-function generateId(prefix = '') {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substr(2, 5);
-    return `${prefix}${timestamp}_${random}`;
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-async function retry(fn, maxAttempts = 3, baseDelay = 1000) {
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt === maxAttempts)
-                throw lastError;
-            const delay = baseDelay * Math.pow(2, attempt - 1);
-            await sleep(delay);
-        }
-    }
-    throw lastError;
-}
-function withTimeout(promise, timeoutMs, message = 'Operation timed out') {
-    const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(message)), timeoutMs);
-    });
-    return Promise.race([promise, timeoutPromise]);
-}
-
-/**
- * @fileoverview Headless checkout cache manager
- */
-/**
- * Manages caching and sequential creation of Primer headless checkout instances.
- * Ensures that multiple checkouts with the same configuration reuse the same instance,
- * and that creations happen sequentially to avoid race conditions.
- */
-class HeadlessManager {
-    constructor() {
-        this.cache = new Map();
-        this.queue = Promise.resolve();
-    }
-    /**
-     * Generates a cache key from clientToken and serializable options
-     */
-    generateKey(clientToken, options) {
-        const serializableOptions = {
-            paymentHandling: options.paymentHandling,
-            apiVersion: options.apiVersion,
-            style: options.style,
-            card: options.card,
-            applePay: options.applePay,
-            paypal: options.paypal,
-            googlePay: options.googlePay,
-        };
-        return `${clientToken}:${JSON.stringify(serializableOptions)}`;
-    }
-    /**
-     * Gets a cached headless instance or creates a new one.
-     * Ensures sequential creation order to avoid race conditions.
-     */
-    getOrCreate(clientToken, options) {
-        const key = this.generateKey(clientToken, options);
-        // Return cached promise if exists
-        const cached = this.cache.get(key);
-        if (cached)
-            return cached;
-        // Create new headless in sequential order
-        const previousQueue = this.queue;
-        const promise = (async () => {
-            await previousQueue; // Wait for previous creation
-            const primerOptions = merge({
-                paymentHandling: 'MANUAL',
-                apiVersion: '2.4',
-            }, options);
-            try {
-                const headlessResult = await window.Primer.createHeadless(clientToken, primerOptions);
-                const headless = await headlessResult;
-                await headless.start();
-                return headless;
-            }
-            catch (error) {
-                // Remove from cache on failure
-                this.cache.delete(key);
-                throw new PrimerError('Failed to create Primer headless checkout', error);
-            }
-        })();
-        this.cache.set(key, promise);
-        this.queue = promise.catch(() => { }); // Update queue, ignore errors
-        return promise;
-    }
-    /**
-     * Removes a headless instance from the cache
-     */
-    remove(headlessPromise) {
-        for (const [key, value] of this.cache.entries()) {
-            if (value === headlessPromise) {
-                this.cache.delete(key);
-                break;
-            }
-        }
-    }
-    /**
-     * Clears all cached instances
-     */
-    clear() {
-        this.cache.clear();
-    }
-}
-
-var PaymentMethod;
-(function (PaymentMethod) {
-    PaymentMethod["GOOGLE_PAY"] = "GOOGLE_PAY";
-    PaymentMethod["APPLE_PAY"] = "APPLE_PAY";
-    PaymentMethod["PAYPAL"] = "PAYPAL";
-    PaymentMethod["PAYMENT_CARD"] = "PAYMENT_CARD";
-})(PaymentMethod || (PaymentMethod = {}));
-
-/**
- * @fileoverview Constants for Funnefox SDK
- */
-const SDK_VERSION = '0.5.7';
-const DEFAULTS = {
-    BASE_URL: 'https://billing.funnelfox.com',
-    REGION: 'default',
-    SANDBOX: false,
-    REQUEST_TIMEOUT: 30000,
-    RETRY_ATTEMPTS: 3,
-    RETRY_BASE_DELAY: 1000,
-};
-const CHECKOUT_STATES = {
-    INITIALIZING: 'initializing',
-    READY: 'ready',
-    PROCESSING: 'processing',
-    ACTION_REQUIRED: 'action_required',
-    UPDATING: 'updating',
-    COMPLETED: 'completed',
-    ERROR: 'error',
-    DESTROYED: 'destroyed',
-};
-const EVENTS = {
-    SUCCESS: 'success',
-    ERROR: 'error',
-    STATUS_CHANGE: 'status-change',
-    DESTROY: 'destroy',
-    INPUT_ERROR: 'input-error',
-    LOADER_CHANGE: 'loader-change',
-    METHOD_RENDER: 'method-render',
-    METHOD_RENDER_ERROR: 'method-render-error',
-    START_PURCHASE: 'start-purchase',
-    PURCHASE_FAILURE: 'purchase-failure',
-    PURCHASE_COMPLETED: 'purchase-completed',
-    PURCHASE_CANCELLED: 'purchase-cancelled',
-    METHODS_AVAILABLE: 'methods-available',
-};
-const API_ENDPOINTS = {
-    CREATE_CLIENT_SESSION: '/v1/checkout/create_client_session',
-    UPDATE_CLIENT_SESSION: '/v1/checkout/update_client_session',
-    CREATE_PAYMENT: '/v1/checkout/create_payment',
-    RESUME_PAYMENT: '/v1/checkout/resume_payment',
-};
-const ERROR_CODES = {
-    SDK_ERROR: 'SDK_ERROR',
-    VALIDATION_ERROR: 'VALIDATION_ERROR',
-    API_ERROR: 'API_ERROR',
-    PRIMER_ERROR: 'PRIMER_ERROR',
-    CHECKOUT_ERROR: 'CHECKOUT_ERROR',
-    CONFIGURATION_ERROR: 'CONFIGURATION_ERROR',
-    NETWORK_ERROR: 'NETWORK_ERROR',
-};
-const ALLOWED_BUTTON_PAYMENT_METHODS = [
-    PaymentMethod.GOOGLE_PAY,
-    PaymentMethod.APPLE_PAY,
-    PaymentMethod.PAYPAL,
-];
-const ALLOWED_CARD_PAYMENT_METHODS = [
-    PaymentMethod.PAYMENT_CARD,
-];
-const ALLOWED_PAYMENT_METHODS = [
-    ...ALLOWED_BUTTON_PAYMENT_METHODS,
-    ...ALLOWED_CARD_PAYMENT_METHODS,
-];
-const inputStyle = {
-    input: {
-        error: {
-            borderColor: 'rgb(227, 47, 65)',
-        },
-        base: {
-            borderWidth: '1px',
-            borderStyle: 'solid',
-            borderColor: 'rgb(0 0 0 / 10%)',
-            height: '36px',
-            paddingHorizontal: 10,
-            borderRadius: '6px',
-        },
-    },
-};
-({
-    paddingLeft: inputStyle.input.base.paddingHorizontal + 'px',
-    paddingRight: inputStyle.input.base.paddingHorizontal + 'px'});
-const DEFAULT_PAYMENT_METHOD_ORDER = [
-    PaymentMethod.APPLE_PAY,
-    PaymentMethod.GOOGLE_PAY,
-    PaymentMethod.PAYPAL,
-    PaymentMethod.PAYMENT_CARD,
-];
-
-/**
- * @fileoverview Primer SDK integration wrapper
- */
-class PrimerWrapper {
-    constructor() {
-        this.isInitialized = false;
-        this.destroyCallbacks = [];
-        this.currentHeadless = null;
-        this.availableMethods = [];
-        this.paymentMethodsInterfaces = [];
-    }
-    isPrimerAvailable() {
-        return (typeof window !== 'undefined' &&
-            window.Primer &&
-            typeof window.Primer?.createHeadless === 'function');
-    }
-    /**
-     * Loads Primer SDK if not already available
-     * @param version - Optional version to load (uses default if not specified)
-     */
-    async ensurePrimerLoaded(version) {
-        if (this.isPrimerAvailable()) {
-            return;
-        }
-        try {
-            await loadPrimerSDK(version);
-        }
-        catch (error) {
-            throw new PrimerError('Failed to load Primer SDK', error);
-        }
-    }
-    ensurePrimerAvailable() {
-        if (!this.isPrimerAvailable()) {
-            throw new PrimerError('Primer SDK not found. Please include the Primer SDK script before initializing FunnefoxSDK.');
-        }
-    }
-    async createHeadlessCheckout(clientToken, options) {
-        await this.ensurePrimerLoaded();
-        this.currentHeadless = PrimerWrapper.headlessManager.getOrCreate(clientToken, options);
-        return this.currentHeadless;
-    }
-    disableButtons(disabled) {
-        if (!this.paymentMethodsInterfaces)
-            return;
-        for (const paymentMethodInterface of this.paymentMethodsInterfaces) {
-            paymentMethodInterface.setDisabled(disabled);
-        }
-    }
-    async renderButton(allowedPaymentMethod, { htmlNode, onMethodRenderError, onMethodRender, }) {
-        let button;
-        // Ensure Primer SDK is loaded
-        await this.ensurePrimerLoaded();
-        if (!this.currentHeadless) {
-            throw new PrimerError('Headless checkout not found');
-        }
-        try {
-            const headless = await this.currentHeadless;
-            const pmManager = await headless.createPaymentMethodManager(allowedPaymentMethod);
-            if (!pmManager) {
-                throw new Error('Payment method manager is not available');
-            }
-            button = pmManager.createButton();
-            await button.render(htmlNode, {});
-            this.destroyCallbacks.push(() => button.clean());
-            onMethodRender(allowedPaymentMethod);
-            return {
-                setDisabled: (disabled) => {
-                    button.setDisabled(disabled);
-                },
-                destroy: () => button.clean(),
-            };
-        }
-        catch (error) {
-            onMethodRenderError(allowedPaymentMethod);
-            throw new PrimerError('Failed to initialize Primer checkout', error);
-        }
-    }
-    async initMethod(method, htmlNode, options) {
-        try {
-            if (method === PaymentMethod.PAYMENT_CARD) {
-                if (!options.cardElements ||
-                    !options.onSubmit ||
-                    !options.onInputChange) {
-                    throw new PrimerError('Card elements, onSubmit, and onInputChange are required for PAYMENT_CARD method');
-                }
-                const cardInterface = await this.renderCardCheckoutWithElements(options.cardElements, {
-                    onSubmit: options.onSubmit,
-                    onInputChange: options.onInputChange,
-                    onMethodRenderError: options.onMethodRenderError,
-                    onMethodRender: options.onMethodRender,
-                });
-                this.paymentMethodsInterfaces.push(cardInterface);
-                return cardInterface;
-            }
-            else {
-                const buttonInterface = await this.renderButton(method, {
-                    htmlNode,
-                    onMethodRenderError: options.onMethodRenderError,
-                    onMethodRender: options.onMethodRender,
-                });
-                this.paymentMethodsInterfaces.push(buttonInterface);
-                return buttonInterface;
-            }
-        }
-        catch (error) {
-            throw new PrimerError('Failed to initialize Primer checkout', error);
-        }
-    }
-    async renderCardCheckoutWithElements(elements, { onSubmit, onInputChange, onMethodRenderError, onMethodRender, }) {
-        try {
-            if (!this.currentHeadless) {
-                throw new PrimerError('Headless checkout not found');
-            }
-            const headless = await this.currentHeadless;
-            const pmManager = await headless.createPaymentMethodManager('PAYMENT_CARD');
-            if (!pmManager) {
-                throw new Error('Payment method manager is not available');
-            }
-            const { cardNumberInput, expiryInput, cvvInput } = pmManager.createHostedInputs();
-            const validateForm = async () => {
-                if (!pmManager)
-                    return false;
-                const { valid, validationErrors } = await pmManager.validate();
-                const cardHolderError = validationErrors.find(v => v.name === 'cardholderName');
-                dispatchError('cardholderName', cardHolderError?.message || null);
-                return valid;
-            };
-            const dispatchError = (inputName, error) => {
-                onInputChange(inputName, error);
-            };
-            const onHostedInputChange = (name) => (event) => {
-                const input = event;
-                if (input.submitted) {
-                    dispatchError(name, input.error);
-                }
-            };
-            const cardHolderOnChange = async (e) => {
-                pmManager.setCardholderName(e.target.value);
-                dispatchError('cardholderName', null);
-            };
-            elements.cardholderName?.addEventListener('input', cardHolderOnChange);
-            cardNumberInput.addEventListener('change', onHostedInputChange('cardNumber'));
-            expiryInput.addEventListener('change', onHostedInputChange('expiryDate'));
-            cvvInput.addEventListener('change', onHostedInputChange('cvv'));
-            const onSubmitHandler = async () => {
-                if (!(await validateForm())) {
-                    return;
-                }
-                try {
-                    onSubmit(true);
-                    await pmManager.submit();
-                }
-                catch (error) {
-                    const primerError = new PrimerError('Failed to submit payment', error);
-                    throw primerError;
-                }
-                finally {
-                    onSubmit(false);
-                }
-            };
-            elements.button?.addEventListener('click', onSubmitHandler);
-            await Promise.all([
-                cardNumberInput.render(elements.cardNumber, {
-                    placeholder: '1234 1234 1234 1234',
-                    ariaLabel: 'Card number',
-                    style: inputStyle,
-                }),
-                expiryInput.render(elements.expiryDate, {
-                    placeholder: 'MM/YY',
-                    ariaLabel: 'Expiry date',
-                    style: inputStyle,
-                }),
-                cvvInput.render(elements.cvv, {
-                    placeholder: '123',
-                    ariaLabel: 'CVV',
-                    style: inputStyle,
-                }),
-            ]);
-            const onDestroy = () => {
-                pmManager.removeHostedInputs();
-                elements.cardholderName?.removeEventListener('change', cardHolderOnChange);
-                elements.button?.removeEventListener('click', onSubmitHandler);
-            };
-            this.destroyCallbacks.push(onDestroy);
-            onMethodRender(PaymentMethod.PAYMENT_CARD);
-            return {
-                setDisabled: (disabled) => {
-                    cardNumberInput.setDisabled(disabled);
-                    expiryInput.setDisabled(disabled);
-                    cvvInput.setDisabled(disabled);
-                    if (elements.button) {
-                        elements.button.disabled = disabled;
-                    }
-                    if (elements.cardholderName) {
-                        elements.cardholderName.disabled = disabled;
-                    }
-                },
-                submit: () => onSubmitHandler(),
-                destroy: () => {
-                    this.destroyCallbacks = this.destroyCallbacks.filter(callback => callback !== onDestroy);
-                    onDestroy();
-                },
-            };
-        }
-        catch (error) {
-            onMethodRenderError(PaymentMethod.PAYMENT_CARD);
-            throw new PrimerError('Failed to initialize Primer checkout', error);
-        }
-    }
-    async initializeHeadlessCheckout(clientToken, primerOptions) {
-        await this.createHeadlessCheckout(clientToken, {
-            ...primerOptions,
-            onTokenizeSuccess: this.wrapTokenizeHandler(primerOptions.onTokenizeSuccess),
-            onResumeSuccess: this.wrapResumeHandler(primerOptions.onResumeSuccess),
-            onAvailablePaymentMethodsLoad: (items) => {
-                let isApplePayAvailable = false;
-                this.availableMethods = ALLOWED_PAYMENT_METHODS.filter(method => {
-                    return items.some((item) => {
-                        if (item.type === PaymentMethod.APPLE_PAY) {
-                            isApplePayAvailable = true;
-                        }
-                        return item.type === method;
-                    });
-                });
-                if (isApplePayAvailable) {
-                    this.availableMethods = this.availableMethods.filter(method => method !== PaymentMethod.GOOGLE_PAY);
-                }
-                if (this.availableMethods.length === 0) {
-                    throw new PrimerError('No allowed payment methods found');
-                }
-            },
-        });
-    }
-    async renderCheckout(clientToken, checkoutOptions, checkoutRenderOptions) {
-        const { cardElements, paymentButtonElements, container, onSubmit, onInputChange, onMethodRender, onMethodRenderError, onMethodsAvailable, } = checkoutRenderOptions;
-        await this.initializeHeadlessCheckout(clientToken, checkoutOptions);
-        onMethodsAvailable?.(this.availableMethods);
-        await Promise.all(this.availableMethods.map(method => {
-            if (method === PaymentMethod.PAYMENT_CARD) {
-                // For card, use the main container
-                return this.initMethod(method, container, {
-                    cardElements,
-                    onSubmit,
-                    onInputChange,
-                    onMethodRender,
-                    onMethodRenderError,
-                });
-            }
-            else {
-                const buttonElementsMap = {
-                    [PaymentMethod.PAYPAL]: paymentButtonElements.paypal,
-                    [PaymentMethod.GOOGLE_PAY]: paymentButtonElements.googlePay,
-                    [PaymentMethod.APPLE_PAY]: paymentButtonElements.applePay,
-                };
-                // For buttons, use the specific button container element
-                const buttonElement = buttonElementsMap[method];
-                return this.initMethod(method, buttonElement, {
-                    onMethodRender,
-                    onMethodRenderError,
-                });
-            }
-        }));
-        this.isInitialized = true;
-    }
-    wrapTokenizeHandler(handler) {
-        return async (paymentMethodTokenData, primerHandler) => {
-            try {
-                await handler(paymentMethodTokenData, primerHandler);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error('Error in tokenize handler:', error);
-                primerHandler.handleFailure('Payment processing failed. Please try again.');
-            }
-        };
-    }
-    wrapResumeHandler(handler) {
-        return async (resumeTokenData, primerHandler) => {
-            try {
-                await handler(resumeTokenData, primerHandler);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error('Error in resume handler:', error);
-                primerHandler.handleFailure('Payment processing failed. Please try again.');
-            }
-        };
-    }
-    async destroy() {
-        if (this.currentHeadless) {
-            PrimerWrapper.headlessManager.remove(this.currentHeadless);
-            this.currentHeadless = null;
-        }
-        if (this.destroyCallbacks) {
-            try {
-                Promise.all(this.destroyCallbacks.map(destroy => destroy()));
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.warn('Error destroying Primer checkout:', error);
-            }
-        }
-        this.destroyCallbacks = [];
-        this.isInitialized = false;
-    }
-    createHandlers(handlers) {
-        return {
-            handleSuccess: () => {
-                if (handlers.onSuccess)
-                    handlers.onSuccess();
-            },
-            handleFailure: (message) => {
-                if (handlers.onError)
-                    handlers.onError(new Error(message));
-            },
-            continueWithNewClientToken: (newClientToken) => {
-                if (handlers.onActionRequired)
-                    handlers.onActionRequired(newClientToken);
-            },
-        };
-    }
-    getCurrentCheckout() {
-        return this.destroyCallbacks;
-    }
-    isActive() {
-        return this.isInitialized && this.destroyCallbacks.length > 0;
-    }
-    validateContainer(selector) {
-        const element = document.querySelector(selector);
-        if (!element) {
-            throw new PrimerError(`Checkout container not found: ${selector}`);
-        }
-        const computedStyle = window.getComputedStyle(element);
-        if (computedStyle.display === 'none') {
-            // eslint-disable-next-line no-console
-            console.warn('Checkout container is hidden, this may cause display issues');
-        }
-        return element;
-    }
-}
-PrimerWrapper.headlessManager = new HeadlessManager();
-
-/**
- * @fileoverview Input validation utilities for Funnefox SDK
- */
-function sanitizeString(input) {
-    return input?.trim() || '';
-}
-function requireString(value, fieldName) {
-    const sanitized = sanitizeString(value);
-    if (sanitized.length === 0) {
-        throw new ValidationError(fieldName, 'must be a non-empty string', value);
-    }
-    return true;
-}
-
-/**
- * @fileoverview API client for Funnefox backend integration
- */
-class APIClient {
-    constructor(config) {
-        this.baseUrl = config.baseUrl.replace(/\/$/, '');
-        this.orgId = config.orgId;
-        this.timeout = config.timeout || 30000;
-        this.retryAttempts = config.retryAttempts || 3;
-    }
-    async request(endpoint, options = {}) {
-        const url = `${this.baseUrl}/${this.orgId}${endpoint}`;
-        const requestOptions = {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-                'X-SDK-Version': SDK_VERSION,
-                ...(options.headers || {}),
-            },
-            ...options,
-        };
-        try {
-            return await retry(async () => {
-                return await withTimeout(this._makeRequest(url, requestOptions), this.timeout, 'Request timed out');
-            }, this.retryAttempts);
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'APIError') {
-                throw error;
-            }
-            throw new NetworkError('Network request failed', error);
-        }
-    }
-    async _makeRequest(url, options) {
-        let response;
-        try {
-            response = await fetch(url, options);
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'NetworkError') {
-                throw error;
-            }
-            throw new NetworkError('Network request failed', error);
-        }
-        let data;
-        try {
-            data = await response.json();
-        }
-        catch {
-            throw new APIError('Invalid JSON response', response.status, {});
-        }
-        if (!response.ok) {
-            const d = data;
-            const message = d.error?.[0]?.msg || 'Failed to create payment';
-            throw new APIError(message, response.status, {
-                response: data,
-            });
-        }
-        return data;
-    }
-    async createClientSession(params) {
-        const payload = {
-            region: params.region || 'default',
-            integration_type: 'primer',
-            pp_ident: params.priceId,
-            external_id: params.externalId,
-            email_address: params.email,
-            client_metadata: params.clientMetadata || {},
-        };
-        if (params.countryCode !== undefined) {
-            payload.country_code = params.countryCode;
-        }
-        return (await this.request(API_ENDPOINTS.CREATE_CLIENT_SESSION, {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        }));
-    }
-    async updateClientSession(params) {
-        const payload = {
-            order_id: params.orderId,
-            client_token: params.clientToken,
-            pp_ident: params.priceId,
-            client_metadata: params.clientMetadata || {},
-        };
-        return await this.request(API_ENDPOINTS.UPDATE_CLIENT_SESSION, {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        });
-    }
-    async createPayment(params) {
-        const payload = {
-            order_id: params.orderId,
-            payment_method_token: params.paymentMethodToken,
-            client_metadata: params.clientMetadata || {},
-        };
-        return (await this.request(API_ENDPOINTS.CREATE_PAYMENT, {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        }));
-    }
-    async resumePayment(params) {
-        const payload = {
-            order_id: params.orderId,
-            resume_token: params.resumeToken,
-        };
-        return (await this.request(API_ENDPOINTS.RESUME_PAYMENT, {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        }));
-    }
-    processSessionResponse(response) {
-        if (response.status === 'error') {
-            const firstError = response.error?.[0];
-            const message = firstError?.msg || 'Session creation failed';
-            throw new APIError(message, null, {
-                errorCode: firstError?.code,
-                errorType: firstError?.type,
-                requestId: response.req_id,
-                response,
-            });
-        }
-        const data = response.data;
-        return {
-            type: 'session_created',
-            orderId: data.order_id,
-            clientToken: data.client_token,
-        };
-    }
-    processPaymentResponse(response) {
-        if (response.status === 'error') {
-            const firstError = response.error?.[0];
-            const message = firstError?.msg || 'Payment request failed';
-            throw new APIError(message, null, {
-                errorCode: firstError?.code,
-                errorType: firstError?.type,
-                response,
-            });
-        }
-        const data = response.data;
-        if (data.action_required_token) {
-            return {
-                type: 'action_required',
-                orderId: data.order_id,
-                clientToken: data.action_required_token,
-            };
-        }
-        if (data.checkout_status) {
-            switch (data.checkout_status) {
-                case 'succeeded':
-                    return {
-                        type: 'success',
-                        orderId: data.order_id,
-                        status: 'succeeded',
-                    };
-                case 'failed':
-                    throw new APIError(data.failed_message_for_user || 'Payment failed', null, { response });
-                case 'cancelled':
-                    throw new APIError('Payment was cancelled by user', null, {
-                        response,
-                    });
-                case 'processing':
-                    return {
-                        type: 'processing',
-                        orderId: data.order_id,
-                        status: 'processing',
-                    };
-                default:
-                    throw new APIError(`Unhandled checkout status: ${data.checkout_status}`, null, { response });
-            }
-        }
-        throw new APIError('Invalid payment response format', null, { response });
-    }
-    async oneClick(payload) {
-        return (await this.request(`/billing/${this.orgId}/v1/checkout/one_click`, {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        }));
-    }
-}
-
-var loaderHtml = "<div class=\"ff-sdk-loader-container\">\n  <div class=\"ff-sdk-loader\"></div>\n</div>\n";
-
-if(typeof document!=="undefined")document.head.appendChild(document.createElement("style")).textContent=".ff-sdk-loader-container {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    background-color: rgba(255, 255, 255);\n    z-index: 2;\n}\n\n.ff-sdk-loader {\n    width: 24px;\n    height: 24px;\n    border: 4px solid #e32f41;\n    border-top: 4px solid transparent;\n    border-radius: 50%;\n    animation: spin 1s linear infinite;\n}\n\n@keyframes spin {\n    0% {\n      transform: rotate(0deg);\n    }\n    100% {\n      transform: rotate(360deg);\n    }\n  }";
-
-const loaderConfig = {
-    html: loaderHtml,
-    selectors: {
-        loaderContainer: '.ff-sdk-loader-container'},
-};
-const renderLoader = (container) => {
-    const loaderContainer = document.querySelector(container);
-    if (loaderContainer) {
-        loaderContainer.innerHTML = loaderConfig.html;
-    }
-};
-const hideLoader = () => {
-    const loaderContainer = document.querySelector(loaderConfig.selectors.loaderContainer);
-    if (loaderContainer) {
-        loaderContainer.remove();
-    }
-};
-
-var V3_URL = 'https://js.stripe.com/v3';
-var V3_URL_REGEX = /^https:\/\/js\.stripe\.com\/v3\/?(\?.*)?$/;
-var EXISTING_SCRIPT_MESSAGE = 'loadStripe.setLoadParameters was called but an existing Stripe.js script already exists in the document; existing script parameters will be used';
-var findScript = function findScript() {
-  var scripts = document.querySelectorAll("script[src^=\"".concat(V3_URL, "\"]"));
-
-  for (var i = 0; i < scripts.length; i++) {
-    var script = scripts[i];
-
-    if (!V3_URL_REGEX.test(script.src)) {
-      continue;
-    }
-
-    return script;
-  }
-
-  return null;
-};
-
-var injectScript = function injectScript(params) {
-  var queryString = '';
-  var script = document.createElement('script');
-  script.src = "".concat(V3_URL).concat(queryString);
-  var headOrBody = document.head || document.body;
-
-  if (!headOrBody) {
-    throw new Error('Expected document.body not to be null. Stripe.js requires a <body> element.');
-  }
-
-  headOrBody.appendChild(script);
-  return script;
-};
-
-var registerWrapper = function registerWrapper(stripe, startTime) {
-  if (!stripe || !stripe._registerWrapper) {
-    return;
-  }
-
-  stripe._registerWrapper({
-    name: 'stripe-js',
-    version: "4.6.0",
-    startTime: startTime
-  });
-};
-
-var stripePromise = null;
-var onErrorListener = null;
-var onLoadListener = null;
-
-var onError = function onError(reject) {
-  return function () {
-    reject(new Error('Failed to load Stripe.js'));
-  };
-};
-
-var onLoad = function onLoad(resolve, reject) {
-  return function () {
-    if (window.Stripe) {
-      resolve(window.Stripe);
-    } else {
-      reject(new Error('Stripe.js not available'));
-    }
-  };
-};
-
-var loadScript = function loadScript(params) {
-  // Ensure that we only attempt to load Stripe.js at most once
-  if (stripePromise !== null) {
-    return stripePromise;
-  }
-
-  stripePromise = new Promise(function (resolve, reject) {
-    if (typeof window === 'undefined' || typeof document === 'undefined') {
-      // Resolve to null when imported server side. This makes the module
-      // safe to import in an isomorphic code base.
-      resolve(null);
-      return;
-    }
-
-    if (window.Stripe) {
-      resolve(window.Stripe);
-      return;
-    }
-
-    try {
-      var script = findScript();
-
-      if (script && params) ; else if (!script) {
-        script = injectScript(params);
-      } else if (script && onLoadListener !== null && onErrorListener !== null) {
-        var _script$parentNode;
-
-        // remove event listeners
-        script.removeEventListener('load', onLoadListener);
-        script.removeEventListener('error', onErrorListener); // if script exists, but we are reloading due to an error,
-        // reload script to trigger 'load' event
-
-        (_script$parentNode = script.parentNode) === null || _script$parentNode === void 0 ? void 0 : _script$parentNode.removeChild(script);
-        script = injectScript(params);
-      }
-
-      onLoadListener = onLoad(resolve, reject);
-      onErrorListener = onError(reject);
-      script.addEventListener('load', onLoadListener);
-      script.addEventListener('error', onErrorListener);
-    } catch (error) {
-      reject(error);
-      return;
-    }
-  }); // Resets stripePromise on error
-
-  return stripePromise["catch"](function (error) {
-    stripePromise = null;
-    return Promise.reject(error);
-  });
-};
-var initStripe = function initStripe(maybeStripe, args, startTime) {
-  if (maybeStripe === null) {
-    return null;
-  }
-
-  var stripe = maybeStripe.apply(undefined, args);
-  registerWrapper(stripe, startTime);
-  return stripe;
-}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-
-var stripePromise$1;
-var loadCalled = false;
-
-var getStripePromise = function getStripePromise() {
-  if (stripePromise$1) {
-    return stripePromise$1;
-  }
-
-  stripePromise$1 = loadScript(null)["catch"](function (error) {
-    // clear cache on error
-    stripePromise$1 = null;
-    return Promise.reject(error);
-  });
-  return stripePromise$1;
-}; // Execute our own script injection after a tick to give users time to do their
-// own script injection.
-
-
-Promise.resolve().then(function () {
-  return getStripePromise();
-})["catch"](function (error) {
-  if (!loadCalled) {
-    console.warn(error);
-  }
-});
-var loadStripe = function loadStripe() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  loadCalled = true;
-  var startTime = Date.now(); // if previous attempts are unsuccessful, will re-load script
-
-  return getStripePromise().then(function (maybeStripe) {
-    return initStripe(maybeStripe, args, startTime);
-  });
-};
-
-var errorHtml = "<div class=\"ff-sdk-error-container\">\n  <p class=\"ff-sdk-error-message\">The payment form didn’t load correctly.</p>\n  <p>Please refresh the page to try again.</p>\n  <p>If the problem persists, please contact support.</p>\n  <p class=\"ff-sdk-error-request-id\"></p>\n</div>\n";
-
-if(typeof document!=="undefined")document.head.appendChild(document.createElement("style")).textContent=".ff-sdk-error-container {\n    background-color: #d1000033;\n    color: #d10000;\n    font-size: 14px;\n    padding: 16px 12px;\n    border-radius: 8px;\n}";
-
-const errorConfig = {
-    html: errorHtml,
-    selectors: {
-        errorRequestId: '.ff-sdk-error-request-id',
-    },
-};
-const renderError = (container, reqId) => {
-    const errorContainer = document.querySelector(container);
-    if (errorContainer) {
-        errorContainer.innerHTML = errorConfig.html;
-        if (reqId) {
-            const errorRequestId = errorContainer.querySelector(errorConfig.selectors.errorRequestId);
-            if (errorRequestId) {
-                errorRequestId.textContent = `Request ID: ${reqId}`;
-            }
-        }
-    }
-};
-
-/**
- * @fileoverview Checkout instance manager for Funnefox SDK
- */
-class CheckoutInstance extends EventEmitter {
-    constructor(config) {
-        super();
-        this.counter = 0;
-        this.radarSessionId = null;
-        this.handleInputChange = (inputName, error) => {
-            this.emit(EVENTS.INPUT_ERROR, { name: inputName, error });
-        };
-        this.handleMethodRender = (method) => {
-            this.emit(EVENTS.METHOD_RENDER, method);
-        };
-        this.handleMethodRenderError = (method) => {
-            this.emit(EVENTS.METHOD_RENDER_ERROR, method);
-        };
-        this.handleSubmit = (isSubmitting) => {
-            this.onLoaderChangeWithRace(isSubmitting);
-            this._setState(isSubmitting ? 'processing' : 'ready');
-        };
-        this.handleTokenizeSuccess = async (paymentMethodTokenData, primerHandler) => {
-            try {
-                this.onLoaderChangeWithRace(true);
-                this._setState('processing');
-                const radarSessionId = await this.radarSessionId;
-                const paymentResponse = await this.apiClient.createPayment({
-                    orderId: this.orderId,
-                    paymentMethodToken: paymentMethodTokenData.token,
-                    clientMetadata: {
-                        radarSessionId,
-                    },
-                });
-                const result = this.apiClient.processPaymentResponse(paymentResponse);
-                await this._processPaymentResult(result, primerHandler);
-            }
-            catch (error) {
-                this._setState('error');
-                this.emit(EVENTS.PURCHASE_FAILURE, new Error(error.message || 'Payment processing failed'));
-                primerHandler.handleFailure(error.message || 'Payment processing failed');
-            }
-            finally {
-                this.onLoaderChangeWithRace(false);
-                this._setState('ready');
-            }
-        };
-        this.handleResumeSuccess = async (resumeTokenData, primerHandler) => {
-            try {
-                this.onLoaderChangeWithRace(true);
-                this._setState('processing');
-                const resumeResponse = await this.apiClient.resumePayment({
-                    orderId: this.orderId,
-                    resumeToken: resumeTokenData.resumeToken,
-                });
-                const result = this.apiClient.processPaymentResponse(resumeResponse);
-                await this._processPaymentResult(result, primerHandler);
-            }
-            catch (error) {
-                this._setState('error');
-                this.emit(EVENTS.PURCHASE_FAILURE, new Error(error.message || 'Payment processing failed'));
-                primerHandler.handleFailure(error.message || 'Payment processing failed');
-            }
-            finally {
-                this.emit(EVENTS.PURCHASE_COMPLETED);
-                this.onLoaderChangeWithRace(false);
-                this._setState('ready');
-            }
-        };
-        this.handleMethodsAvailable = (methods) => {
-            this.emit(EVENTS.METHODS_AVAILABLE, methods);
-        };
-        this.onLoaderChangeWithRace = (state) => {
-            const isLoading = !!(state ? ++this.counter : --this.counter);
-            this.primerWrapper.disableButtons(isLoading);
-            this.emit(EVENTS.LOADER_CHANGE, isLoading);
-        };
-        this.id = generateId('checkout_');
-        this.orgId = config.orgId;
-        this.baseUrl = config.baseUrl;
-        this.region = config.region;
-        this.checkoutConfig = { ...config.checkoutConfig };
-        this.callbacks = {
-            onSuccess: this.checkoutConfig.onSuccess,
-            onError: this.checkoutConfig.onError,
-            onStatusChange: this.checkoutConfig.onStatusChange,
-            onDestroy: this.checkoutConfig.onDestroy,
-        };
-        delete this.checkoutConfig?.onSuccess;
-        delete this.checkoutConfig?.onError;
-        delete this.checkoutConfig?.onStatusChange;
-        delete this.checkoutConfig?.onDestroy;
-        this.state = 'initializing';
-        this.orderId = null;
-        this.clientToken = null;
-        this.primerWrapper = new PrimerWrapper();
-        this.isDestroyed = false;
-        this._setupCallbackBridges();
-    }
-    _setupCallbackBridges() {
-        if (this.callbacks.onSuccess) {
-            this.on(EVENTS.SUCCESS, this.callbacks.onSuccess);
-        }
-        if (this.callbacks.onError) {
-            this.on(EVENTS.ERROR, this.callbacks.onError);
-        }
-        if (this.callbacks.onStatusChange) {
-            this.on(EVENTS.STATUS_CHANGE, this.callbacks.onStatusChange);
-        }
-        if (this.callbacks.onDestroy) {
-            this.on(EVENTS.DESTROY, this.callbacks.onDestroy);
-        }
-    }
-    removeAllListeners() {
-        return super.removeAllListeners();
-    }
-    async initialize() {
-        try {
-            this.showInitializingLoader();
-            this._setState('initializing');
-            await this.createSession();
-            await this._initializePrimerCheckout();
-            this._setState('ready');
-            this.checkoutConfig?.onInitialized?.();
-            return this;
-        }
-        catch (error) {
-            this._setState('error');
-            renderError(this.checkoutConfig.container, error?.response?.req_id);
-            this.emit(EVENTS.ERROR, error);
-            throw error;
-        }
-        finally {
-            this.hideInitializingLoader();
-        }
-    }
-    async createSession() {
-        this.apiClient = new APIClient({
-            baseUrl: this.baseUrl || DEFAULTS.BASE_URL,
-            orgId: this.orgId,
-            timeout: DEFAULTS.REQUEST_TIMEOUT,
-            retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
-        });
-        const sessionParams = {
-            priceId: this.checkoutConfig.priceId,
-            externalId: this.checkoutConfig.customer.externalId,
-            email: this.checkoutConfig.customer.email,
-            region: this.region || DEFAULTS.REGION,
-            clientMetadata: this.checkoutConfig.clientMetadata,
-            countryCode: this.checkoutConfig.customer.countryCode,
-        };
-        const cacheKey = [
-            this.orgId,
-            this.checkoutConfig.priceId,
-            this.checkoutConfig.customer.externalId,
-            this.checkoutConfig.customer.email,
-        ].join('-');
-        let sessionResponse;
-        // Return cached response if payload hasn't changed
-        const cachedResponse = CheckoutInstance.sessionCache.get(cacheKey);
-        if (cachedResponse) {
-            sessionResponse = await cachedResponse;
-        }
-        else {
-            const sessionRequest = this.apiClient
-                .createClientSession(sessionParams)
-                .then(response => {
-                if (response.data?.stripe_public_key) {
-                    loadStripe(response.data?.stripe_public_key).then(stripe => {
-                        this.radarSessionId = stripe
-                            .createRadarSession()
-                            .then(session => session?.radarSession?.id)
-                            .catch(() => '');
-                    });
-                }
-                return response;
-            });
-            // Cache the successful response
-            CheckoutInstance.sessionCache.set(cacheKey, sessionRequest);
-            sessionResponse = await sessionRequest;
-        }
-        const sessionData = this.apiClient.processSessionResponse(sessionResponse);
-        this.orderId = sessionData.orderId;
-        this.clientToken = sessionData.clientToken;
-    }
-    convertCardSelectorsToElements(selectors, container) {
-        const cardNumber = container.querySelector(selectors.cardNumber);
-        const expiryDate = container.querySelector(selectors.expiryDate);
-        const cvv = container.querySelector(selectors.cvv);
-        const cardholderName = container.querySelector(selectors.cardholderName);
-        const button = container.querySelector(selectors.button);
-        if (!cardNumber || !expiryDate || !cvv || !button) {
-            throw new CheckoutError('Required card input elements not found in container');
-        }
-        return {
-            cardNumber,
-            expiryDate,
-            cvv,
-            cardholderName,
-            button,
-        };
-    }
-    convertPaymentButtonSelectorsToElements(selectors) {
-        const paypal = document.querySelector(selectors.paypal);
-        const googlePay = document.querySelector(selectors.googlePay);
-        const applePay = document.querySelector(selectors.applePay);
-        if (!paypal || !googlePay || !applePay) {
-            throw new CheckoutError('Required payment button elements not found in container');
-        }
-        return {
-            paypal,
-            googlePay,
-            applePay,
-        };
-    }
-    async _initializePrimerCheckout() {
-        // Get container element
-        const containerElement = this.getContainer();
-        if (!containerElement) {
-            throw new CheckoutError(`Checkout container not found: ${this.checkoutConfig.container}`);
-        }
-        // Get selectors (either from config or default skin)
-        let cardElements;
-        let paymentButtonElements;
-        let checkoutOptions;
-        if (!this.checkoutConfig.cardSelectors ||
-            !this.checkoutConfig.paymentButtonSelectors) {
-            this.checkoutConfig.paymentMethodOrder =
-                this.checkoutConfig.paymentMethodOrder || DEFAULT_PAYMENT_METHOD_ORDER;
-            const defaultSkinCheckoutOptions = await this.getDefaultSkinCheckoutOptions();
-            if (!defaultSkinCheckoutOptions.cardElements ||
-                !defaultSkinCheckoutOptions.paymentButtonElements) {
-                throw new CheckoutError('Default skin must provide cardSelectors and paymentButtonSelectors');
-            }
-            cardElements =
-                defaultSkinCheckoutOptions.cardElements;
-            paymentButtonElements = defaultSkinCheckoutOptions.paymentButtonElements;
-            checkoutOptions = this.getCheckoutOptions(defaultSkinCheckoutOptions);
-        }
-        else {
-            if (this.checkoutConfig.paymentMethodOrder) {
-                // eslint-disable-next-line no-console
-                console.warn('paymentMethodOrder is using only for default skin and will be ignored if you are using custom checkout');
-            }
-            cardElements = this.convertCardSelectorsToElements(this.checkoutConfig.cardSelectors, containerElement);
-            paymentButtonElements = this.convertPaymentButtonSelectorsToElements(this.checkoutConfig.paymentButtonSelectors);
-            checkoutOptions = this.getCheckoutOptions({});
-        }
-        await this.primerWrapper.renderCheckout(this.clientToken, checkoutOptions, {
-            container: containerElement,
-            cardElements,
-            paymentButtonElements,
-            onSubmit: this.handleSubmit,
-            onInputChange: this.handleInputChange,
-            onMethodRender: this.handleMethodRender,
-            onMethodsAvailable: this.handleMethodsAvailable,
-            onMethodRenderError: this.handleMethodRenderError,
-        });
-    }
-    async _processPaymentResult(result, primerHandler) {
-        if (result.orderId) {
-            this.orderId = result.orderId;
-        }
-        switch (result.type) {
-            case 'success':
-                this._setState('completed');
-                this.emit(EVENTS.SUCCESS, {
-                    orderId: result.orderId,
-                    status: result.status,
-                });
-                primerHandler.handleSuccess();
-                break;
-            case 'action_required':
-                this._setState('action_required');
-                this.clientToken = result.clientToken;
-                primerHandler.continueWithNewClientToken(result.clientToken);
-                break;
-            case 'processing':
-                this._setState('processing');
-                setTimeout(() => {
-                    primerHandler.handleFailure('Payment is still processing. Please check back later.');
-                }, 30000);
-                break;
-            default:
-                throw new CheckoutError(`Unknown payment result type: ${result.type}`);
-        }
-    }
-    getCheckoutOptions(options) {
-        let wasPaymentProcessedStarted = false;
-        return {
-            ...this.checkoutConfig,
-            ...options,
-            onTokenizeSuccess: this.handleTokenizeSuccess,
-            onResumeSuccess: this.handleResumeSuccess,
-            onResumeError: error => {
-                if (error.stack?.includes('PROCESSOR_3DS') &&
-                    error.code === 'RESUME_ERROR' &&
-                    error.message?.includes('fetch resume key')) {
-                    // Ignore 3DS close error, because it is not understandable by user
-                    return;
-                }
-                this.emit(EVENTS.PURCHASE_FAILURE, error);
-            },
-            onCheckoutFail: error => {
-                this.emit(EVENTS.PURCHASE_FAILURE, error);
-            },
-            onTokenizeError: error => {
-                this.emit(EVENTS.PURCHASE_FAILURE, error);
-            },
-            onTokenizeShouldStart: data => {
-                wasPaymentProcessedStarted = true;
-                this.emit(EVENTS.ERROR, undefined);
-                this.emit(EVENTS.START_PURCHASE, data.paymentMethodType);
-                return true;
-            },
-            onPaymentMethodAction: action => {
-                switch (action) {
-                    case 'PAYMENT_METHOD_SELECTED':
-                        this.emit(EVENTS.ERROR, undefined);
-                        break;
-                    case 'PAYMENT_METHOD_UNSELECTED':
-                        if (!wasPaymentProcessedStarted) {
-                            this.emit(EVENTS.PURCHASE_CANCELLED);
-                        }
-                        wasPaymentProcessedStarted = false;
-                        break;
-                }
-            },
-        };
-    }
-    async updatePrice(newPriceId, clientMetadata) {
-        this._ensureNotDestroyed();
-        requireString(newPriceId, 'priceId');
-        if (this.state === 'processing') {
-            throw new CheckoutError('Cannot update price while payment is processing');
-        }
-        try {
-            this._setState('updating');
-            // Invalidate session cache
-            CheckoutInstance.sessionCache.clear();
-            await this.apiClient.updateClientSession({
-                orderId: this.orderId,
-                clientToken: this.clientToken,
-                priceId: newPriceId,
-                clientMetadata,
-            });
-            this.checkoutConfig.priceId = newPriceId;
-            this._setState('ready');
-        }
-        catch (error) {
-            this._setState('error');
-            this.emit(EVENTS.ERROR, error);
-            throw error;
-        }
-    }
-    getStatus() {
-        return {
-            id: this.id,
-            state: this.state,
-            orderId: this.orderId,
-            priceId: this.checkoutConfig.priceId,
-            isDestroyed: this.isDestroyed,
-        };
-    }
-    async destroy() {
-        if (this.isDestroyed)
-            return;
-        try {
-            CheckoutInstance.sessionCache.clear();
-            await this.primerWrapper.destroy();
-            this._setState('destroyed');
-            this.orderId = null;
-            this.clientToken = null;
-            this.isDestroyed = true;
-            this.emit(EVENTS.DESTROY);
-            this.removeAllListeners();
-        }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.warn('Error during checkout cleanup:', error);
-        }
-    }
-    _setState(newState) {
-        if (this.state !== newState) {
-            const oldState = this.state;
-            this.state = newState;
-            this.emit(EVENTS.STATUS_CHANGE, newState, oldState);
-        }
-    }
-    _ensureNotDestroyed() {
-        if (this.isDestroyed) {
-            throw new CheckoutError('Checkout instance has been destroyed');
-        }
-    }
-    getContainer() {
-        return document.querySelector(this.checkoutConfig.container);
-    }
-    isInState(state) {
-        return this.state === state;
-    }
-    isReady() {
-        return this.state === 'ready' && !this.isDestroyed;
-    }
-    isProcessing() {
-        return ['processing', 'action_required'].includes(this.state);
-    }
-    // Creates containers to render hosted inputs with labels and error messages,
-    // a card holder input with label and error, and a submit button.
-    async getDefaultSkinCheckoutOptions() {
-        const skinFactory = (await import('./chunk-index.es.js'))
-            .default;
-        const skin = await skinFactory(this.checkoutConfig);
-        this.on(EVENTS.INPUT_ERROR, skin.onInputError);
-        this.on(EVENTS.STATUS_CHANGE, skin.onStatusChange);
-        this.on(EVENTS.ERROR, (error) => skin.onError(error));
-        this.on(EVENTS.LOADER_CHANGE, skin.onLoaderChange);
-        this.on(EVENTS.DESTROY, skin.onDestroy);
-        this.on(EVENTS.SUCCESS, skin.onSuccess);
-        this.on(EVENTS.START_PURCHASE, skin.onStartPurchase);
-        this.on(EVENTS.PURCHASE_FAILURE, skin.onPurchaseFailure);
-        this.on(EVENTS.PURCHASE_COMPLETED, skin.onPurchaseCompleted);
-        this.on(EVENTS.METHODS_AVAILABLE, skin.onMethodsAvailable);
-        this.on(EVENTS.METHODS_AVAILABLE, this.hideInitializingLoader);
-        return skin.getCheckoutOptions();
-    }
-    async getCardDefaultSkinCheckoutOptions(node) {
-        const CardSkin = (await import('./chunk-index.es2.js')).default;
-        const skin = new CardSkin(node, this.checkoutConfig);
-        skin.init();
-        this.on(EVENTS.INPUT_ERROR, skin.onInputError);
-        this.on(EVENTS.METHOD_RENDER, skin.onMethodRender);
-        this.on(EVENTS.SUCCESS, skin.onDestroy);
-        this.on(EVENTS.DESTROY, skin.onDestroy);
-        return skin.getCheckoutOptions();
-    }
-    showInitializingLoader() {
-        renderLoader(this.checkoutConfig.container);
-    }
-    hideInitializingLoader() {
-        hideLoader();
-    }
-    async initMethod(method, element, callbacks) {
-        this._ensureNotDestroyed();
-        if (!this.isReady()) {
-            await this.createSession();
-        }
-        if (callbacks.onRenderSuccess) {
-            this.on(EVENTS.METHOD_RENDER, callbacks.onRenderSuccess);
-        }
-        if (callbacks.onRenderError) {
-            this.on(EVENTS.METHOD_RENDER_ERROR, callbacks.onRenderError);
-        }
-        if (callbacks.onLoaderChange) {
-            this.on(EVENTS.LOADER_CHANGE, callbacks.onLoaderChange);
-        }
-        if (callbacks.onPaymentSuccess) {
-            this.on(EVENTS.SUCCESS, callbacks.onPaymentSuccess);
-        }
-        if (callbacks.onPaymentFail) {
-            this.on(EVENTS.PURCHASE_FAILURE, callbacks.onPaymentFail);
-        }
-        if (callbacks.onPaymentCancel) {
-            this.on(EVENTS.PURCHASE_CANCELLED, callbacks.onPaymentCancel);
-        }
-        if (callbacks.onErrorMessageChange) {
-            this.on(EVENTS.ERROR, callbacks.onErrorMessageChange);
-        }
-        if (callbacks.onPaymentStarted) {
-            this.on(EVENTS.START_PURCHASE, callbacks.onPaymentStarted);
-        }
-        if (callbacks.onMethodsAvailable) {
-            this.on(EVENTS.METHODS_AVAILABLE, callbacks.onMethodsAvailable);
-        }
-        let checkoutOptions = this.getCheckoutOptions({});
-        let methodOptions = {
-            onMethodRender: this.handleMethodRender,
-            onMethodRenderError: this.handleMethodRenderError,
-        };
-        if (method === PaymentMethod.PAYMENT_CARD) {
-            const cardDefaultOptions = await this.getCardDefaultSkinCheckoutOptions(element);
-            checkoutOptions = this.getCheckoutOptions({
-                ...cardDefaultOptions,
-            });
-            methodOptions = {
-                cardElements: cardDefaultOptions.cardElements,
-                onSubmit: this.handleSubmit,
-                onInputChange: this.handleInputChange,
-                onMethodRender: this.handleMethodRender,
-                onMethodRenderError: this.handleMethodRenderError,
-            };
-        }
-        await this.primerWrapper.initializeHeadlessCheckout(this.clientToken, checkoutOptions);
-        const methodInterface = await this.primerWrapper.initMethod(method, element, methodOptions);
-        return {
-            ...methodInterface,
-            destroy: async () => {
-                await methodInterface.destroy();
-                await this.destroy();
-            },
-        };
-    }
-}
-CheckoutInstance.sessionCache = new Map();
-
-function getErrorImage(orgId, options) {
-    const params = new URLSearchParams({
-        message: options.message,
-        code: options.code,
-        timestamp: Date.now().toString(),
-        sdk_version: SDK_VERSION,
-    });
-    if (options.req_id) {
-        params.append('req_id', options.req_id);
-    }
-    const url = `https://billing.funnelfox.com/sdk_report/${encodeURIComponent(orgId)}/crash?${params.toString()}`;
-    const img = new Image();
-    img.src = url;
-    img.style.display = 'none';
-    document.body.appendChild(img);
-}
-
-/**
- * @fileoverview Public API with configuration and orchestration logic
- */
-let defaultConfig = null;
-function configure(config) {
-    defaultConfig = config;
-}
-function resolveConfig(options, functionName) {
-    const { orgId, apiConfig } = options || {};
-    const finalOrgId = orgId || defaultConfig?.orgId;
-    if (!finalOrgId) {
-        throw new Error(`orgId is required. Pass it to ${functionName}() or call configure() first.`);
-    }
-    const finalBaseUrl = apiConfig?.baseUrl || defaultConfig?.baseUrl || DEFAULTS.BASE_URL;
-    const finalRegion = apiConfig?.region || defaultConfig?.region || DEFAULTS.REGION;
-    return {
-        orgId: finalOrgId,
-        baseUrl: finalBaseUrl,
-        region: finalRegion,
-    };
-}
-async function createCheckout(options) {
-    try {
-        const { ...checkoutConfig } = options;
-        // Ensure Primer SDK is loaded before creating checkout
-        const primerWrapper = new PrimerWrapper();
-        await primerWrapper.ensurePrimerLoaded();
-        const config = resolveConfig(options, 'createCheckout');
-        const checkout = new CheckoutInstance({
-            ...config,
-            checkoutConfig: {
-                ...checkoutConfig,
-            },
-        });
-        await checkout.initialize();
-        return checkout;
-    }
-    catch (error) {
-        getErrorImage(options.orgId, {
-            message: error.message,
-            code: error.code,
-            req_id: error?.response?.req_id,
-        });
-        throw error;
-    }
-}
-async function createClientSession(params) {
-    const { priceId, externalId, email, clientMetadata, countryCode } = params;
-    const config = resolveConfig(params, 'createClientSession');
-    const apiClient = new APIClient({
-        baseUrl: config.baseUrl,
-        orgId: config.orgId,
-        timeout: DEFAULTS.REQUEST_TIMEOUT,
-        retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
-    });
-    const sessionResponse = await apiClient.createClientSession({
-        priceId,
-        externalId,
-        email,
-        region: config.region,
-        clientMetadata,
-        countryCode,
-    });
-    return apiClient.processSessionResponse(sessionResponse);
-}
-async function silentPurchase(options) {
-    const { priceId, externalId, clientMetadata, orgId, baseUrl } = options;
-    const apiClient = new APIClient({
-        baseUrl: baseUrl,
-        orgId: orgId,
-        timeout: DEFAULTS.REQUEST_TIMEOUT,
-        retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
-    });
-    try {
-        const response = await apiClient.oneClick({
-            pp_ident: priceId,
-            external_id: externalId,
-            client_metadata: clientMetadata,
-        });
-        if (response.status !== 'success' &&
-            response.error.some(({ code }) => code === 'double_purchase')) {
-            throw new APIError('This product was already purchased');
-        }
-        else if (response.status !== 'success') {
-            return false;
-        }
-        return true;
-    }
-    catch (error) {
-        getErrorImage(orgId, {
-            message: error.message,
-            code: error.code,
-            req_id: error?.response?.req_id,
-        });
-        throw error;
-    }
-}
-async function initMethod(method, element, options) {
-    try {
-        const checkoutInstance = new CheckoutInstance({
-            orgId: options.orgId,
-            baseUrl: options.baseUrl,
-            checkoutConfig: {
-                priceId: options.priceId,
-                customer: {
-                    externalId: options.externalId,
-                    email: options.email,
-                },
-                container: '',
-                clientMetadata: options.meta,
-                card: options.card,
-                style: options.style,
-                applePay: options.applePay,
-                paypal: options.paypal,
-                googlePay: options.googlePay,
-            },
-        });
-        return checkoutInstance.initMethod(method, element, {
-            onRenderSuccess: options.onRenderSuccess,
-            onRenderError: options.onRenderError,
-            onLoaderChange: options.onLoaderChange,
-            onPaymentSuccess: options.onPaymentSuccess,
-            onPaymentFail: options.onPaymentFail,
-            onPaymentCancel: options.onPaymentCancel,
-            onErrorMessageChange: options.onErrorMessageChange,
-            onPaymentStarted: options.onPaymentStarted,
-            onMethodsAvailable: options.onMethodsAvailable,
-        });
-    }
-    catch (error) {
-        getErrorImage(options.orgId, {
-            message: error.message,
-            code: error.code,
-            req_id: error?.response?.req_id,
-        });
-        throw error;
-    }
-}
-
-/**
- * @fileoverview Main entry point for @funnelfox/billing
- */
-const Billing = {
-    configure: configure,
-    createCheckout: createCheckout,
-    createClientSession: createClientSession,
-    initMethod: initMethod,
-    silentPurchase: silentPurchase,
-};
-if (typeof window !== 'undefined') {
-    window.Billing = Billing;
-}
-
-export { APIError, Billing, CHECKOUT_STATES, CheckoutError, ConfigurationError, DEFAULTS, ERROR_CODES, EVENTS, FunnefoxSDKError, NetworkError, PaymentMethod, PrimerError, SDK_VERSION, ValidationError, configure, createCheckout, createClientSession, Billing as default };
+export { A as APIError, B as Billing, d as CHECKOUT_STATES, C as CheckoutError, b as ConfigurationError, c as DEFAULTS, e as ERROR_CODES, E as EVENTS, F as FunnefoxSDKError, N as NetworkError, P as PaymentMethod, a as PrimerError, S as SDK_VERSION, V as ValidationError, f as configure, g as createCheckout, h as createClientSession, B as default } from './chunk-index.es.js';