@zonos/elements 1.3.254 → 1.3.256

package/dist/collection/components/utils/checkout/bigcommerceStorefrontApi.js

@@ -0,0 +1,52 @@
+import { log } from "../logging/log";
+import { logError } from "../logging/logError";
+/**
+ * Fetch the checkout/cart ID from the BigCommerce Storefront Cart API.
+ * The `/checkout` page URL does not include the checkout ID, so we
+ * retrieve it from `/api/storefront/cart` which returns the active cart(s).
+ */
+export const fetchCheckoutId = async () => {
+    var _a, _b;
+    try {
+        const response = await fetch('/api/storefront/cart', {
+            credentials: 'same-origin',
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        if (!response.ok) {
+            log(`Failed to fetch BigCommerce cart: ${String(response.status)}`, 'error');
+            return null;
+        }
+        const carts = (await response.json());
+        return (_b = (_a = carts === null || carts === void 0 ? void 0 : carts[0]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
+    }
+    catch (error) {
+        logError('Error fetching BigCommerce cart data', error);
+        return null;
+    }
+};
+/**
+ * Fetch checkout data from the BigCommerce Storefront API.
+ * This API is cookie-authenticated (same-origin), so no token is needed.
+ */
+export const fetchBigCommerceCheckout = async (checkoutId) => {
+    try {
+        const response = await fetch(`/api/storefront/checkouts/${checkoutId}?include=customer.customerGroup`, {
+            credentials: 'same-origin',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            log(`Failed to fetch BigCommerce checkout: ${String(response.status)}`, 'error');
+            return null;
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        logError('Error fetching BigCommerce checkout data', error);
+        return null;
+    }
+};

package/dist/collection/components/utils/checkout/buildBigcommerceRedirectUrl.js

@@ -0,0 +1,22 @@
+import { getIsTestMode } from "./getIsTestMode";
+/**
+ * Build an absolute redirect URL used by the BigCommerce checkout flows to
+ * navigate between the BC native `/checkout` page and the Zonos international
+ * checkout at `/`.
+ *
+ * Carries over the `zonosQaUrl` query param from the current URL (when
+ * present) so the preview Zonos elements build keeps loading after the
+ * redirect, and sets `zonosTestMode=1` when test mode is active so the
+ * destination page continues to use the test credentials.
+ */
+export const buildBigcommerceRedirectUrl = (pathname) => {
+    const url = new URL(pathname, window.location.origin);
+    const zonosQaUrl = new URLSearchParams(window.location.search).get('zonosQaUrl');
+    if (zonosQaUrl) {
+        url.searchParams.set('zonosQaUrl', zonosQaUrl);
+    }
+    if (getIsTestMode()) {
+        url.searchParams.set('zonosTestMode', '1');
+    }
+    return url.toString();
+};

package/dist/collection/components/utils/checkout/checkBigCommerceBypassCustomerGroup.js

@@ -0,0 +1,122 @@
+import { zonosStore } from "../../store/zonosStore";
+import { fetchBigCommerceCheckout, fetchCheckoutId, } from "./bigcommerceStorefrontApi";
+import { log } from "../logging/log";
+const DEFAULT_RESULT = {
+    customerGroupId: null,
+    shouldBypass: false,
+};
+/**
+ * Performs the actual fetch logic to determine if the customer
+ * belongs to a bypass group.
+ */
+const fetchBypassOutcome = async () => {
+    var _a, _b, _c, _d;
+    // Only relevant for BigCommerce stores — permanent no-op on other platforms
+    if (!window.Zonos.isBigCommerce) {
+        return { conclusive: true, result: DEFAULT_RESULT };
+    }
+    const bypassGroupIds = (_a = zonosStore.genericSettings) === null || _a === void 0 ? void 0 : _a.bigcommerceBypassCustomerGroupIds;
+    if (!(bypassGroupIds === null || bypassGroupIds === void 0 ? void 0 : bypassGroupIds.length)) {
+        if (zonosStore.loadedConfig) {
+            // Settings have finished loading and there are no bypass groups
+            // configured — this is a permanent "bypass not configured" answer.
+            return { conclusive: true, result: DEFAULT_RESULT };
+        }
+        // Settings haven't loaded yet — the empty list may be transient.
+        // Mark as inconclusive so a later caller retries after config loads.
+        return { conclusive: false, result: DEFAULT_RESULT };
+    }
+    // Fetch customer group from BigCommerce Storefront API
+    const checkoutId = await fetchCheckoutId();
+    if (!checkoutId) {
+        // No active cart yet — inconclusive. Common on fresh sessions where
+        // `initBigCommerceBypassCheck` runs before the user has added anything
+        // to their cart; once the cart exists we need to re-fetch.
+        log('BigCommerce bypass check: no active cart yet, will retry on next call', 'info');
+        return { conclusive: false, result: DEFAULT_RESULT };
+    }
+    const checkout = await fetchBigCommerceCheckout(checkoutId);
+    if (!checkout) {
+        // API call failed (network error, non-200, etc.) — inconclusive.
+        // Caching this would permanently disable bypass for the session if
+        // the logged-in user is actually a reseller.
+        log('BigCommerce bypass check: failed to fetch checkout data, will retry', 'info');
+        return { conclusive: false, result: DEFAULT_RESULT };
+    }
+    const customerGroupId = (_d = (_c = (_b = checkout.customer) === null || _b === void 0 ? void 0 : _b.customerGroup) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : null;
+    if (customerGroupId === null) {
+        log('BigCommerce bypass check: no customer group found (guest user)', 'info');
+        // Guest user with an active cart — a definitive "no bypass" answer.
+        return { conclusive: true, result: DEFAULT_RESULT };
+    }
+    const shouldBypass = bypassGroupIds.includes(customerGroupId);
+    const result = { customerGroupId, shouldBypass };
+    if (shouldBypass) {
+        log(`BigCommerce bypass check: customer group ${String(customerGroupId)} is in bypass list; caller should keep the user on BC native checkout`, 'info');
+    }
+    else {
+        log(`BigCommerce bypass check: customer group ${String(customerGroupId)} is not in bypass list`, 'info');
+    }
+    return { conclusive: true, result };
+};
+/**
+ * Module-level promise that holds the in-flight or resolved bypass check.
+ * Set by `initBigCommerceBypassCheck` on page load so the result is ready
+ * by the time checkout opens or the watcher fires.
+ *
+ * Automatically invalidated when a fetch resolves to an inconclusive outcome,
+ * so subsequent callers retry (e.g. after the user adds an item to their
+ * cart or after settings finish loading).
+ */
+let bypassCheckPromise = null;
+const startBypassCheck = () => {
+    const outcomePromise = fetchBypassOutcome();
+    const resultPromise = outcomePromise.then(({ conclusive, result }) => {
+        if (!conclusive && bypassCheckPromise === resultPromise) {
+            // Invalidate cache so the next caller performs a fresh fetch.
+            bypassCheckPromise = null;
+        }
+        return result;
+    });
+    bypassCheckPromise = resultPromise;
+    return resultPromise;
+};
+/**
+ * Start fetching the BigCommerce customer group on page load.
+ * Call this once during initialization (e.g. in `zonos-checkout.init()`).
+ * The fetch runs in the background; `checkBigCommerceBypassCustomerGroup`
+ * will await the result when needed.
+ */
+export const initBigCommerceBypassCheck = () => {
+    var _a;
+    if (!window.Zonos.isBigCommerce) {
+        return;
+    }
+    const bypassGroupIds = (_a = zonosStore.genericSettings) === null || _a === void 0 ? void 0 : _a.bigcommerceBypassCustomerGroupIds;
+    if (!(bypassGroupIds === null || bypassGroupIds === void 0 ? void 0 : bypassGroupIds.length)) {
+        return;
+    }
+    // Fire the fetch immediately; consumers will await the same promise
+    void startBypassCheck();
+};
+/**
+ * Check if the current BigCommerce customer belongs to a customer group
+ * that should bypass Zonos Checkout.
+ *
+ * If `initBigCommerceBypassCheck` was called on page load and the resulting
+ * outcome was conclusive, this returns the already-resolved (or in-flight)
+ * result without making additional API calls. If the previous outcome was
+ * inconclusive (no cart, settings not loaded), the cache was invalidated
+ * automatically and this triggers a fresh fetch.
+ *
+ * @param options.forceRefresh - When true, bypasses any cached result and
+ * always fetches fresh BigCommerce checkout data. Use this on the
+ * BigCommerce domestic checkout page when the shipping country changes,
+ * to ensure the customer group reflects the current checkout state.
+ */
+export const checkBigCommerceBypassCustomerGroup = async (options = {}) => {
+    if (options.forceRefresh || !bypassCheckPromise) {
+        return startBypassCheck();
+    }
+    return bypassCheckPromise;
+};

package/dist/collection/components/utils/checkout/watchBigcommerceDomesticCheckout.js

@@ -1,6 +1,7 @@
 import { stripeStoreCleanupDomesticShippingSession, stripeStoreGetDomesticShippingSession, stripeStoreSaveDomesticShippingSession, } from "../../store/checkout/stripe";
 import { localizationStoreUpdateSelectedCountryCode } from "../../store/hello/localization";
 import { zonosStore } from "../../store/zonosStore";
+import { buildBigcommerceRedirectUrl } from "./buildBigcommerceRedirectUrl";
 import { isShippableCountry } from "./isShippableCountry";
 import { logError } from "../logging/logError";
 import { sendErrorLog } from "../logging/sendErrorLog";
@@ -102,8 +103,10 @@ export const watchBigcommerceDomesticCheckout = ({ domesticRedirectedBtnSelector
             });
             e.preventDefault();
             e.stopPropagation();
-            // redirect to home page, home page then will open the checkout dialog if having domestic shipping session
-            window.location.href = '/';
+            // redirect to home page, home page then will open the checkout dialog if
+            // having domestic shipping session. Carry over zonosQaUrl / zonosTestMode
+            // so the destination page keeps using the same build/env.
+            window.location.href = buildBigcommerceRedirectUrl('/');
         });
     });
     observer.observe(document.body, {

package/dist/collection/components/utils/checkout/watchImmediateBigcommerceDomesticCheckoutRedirect.js

@@ -1,81 +1,56 @@
 import { stripeStoreGetDomesticShippingSession, stripeStoreSaveDomesticShippingSession, } from "../../store/checkout/stripe";
 import { localizationStoreUpdateSelectedCountryCode } from "../../store/hello/localization";
 import { zonosStore } from "../../store/zonosStore";
+import { fetchBigCommerceCheckout, fetchCheckoutId, } from "./bigcommerceStorefrontApi";
+import { buildBigcommerceRedirectUrl } from "./buildBigcommerceRedirectUrl";
+import { checkBigCommerceBypassCustomerGroup } from "./checkBigCommerceBypassCustomerGroup";
 import { isShippableCountry } from "./isShippableCountry";
 import { log } from "../logging/log";
 import { logError } from "../logging/logError";
 const FALLBACK_SHIP_TO_COUNTRY_SELECTOR = 'select[name="shippingAddress.countryCode"]';
-/**
- * Fetch the checkout/cart ID from the BigCommerce Storefront Cart API.
- * The `/checkout` page URL does not include the checkout ID, so we
- * retrieve it from `/api/storefront/cart` which returns the active cart(s).
- */
-const fetchCheckoutId = async () => {
-    var _a, _b;
-    try {
-        const response = await fetch('/api/storefront/cart', {
-            credentials: 'same-origin',
-            headers: {
-                Accept: 'application/json',
-            },
-        });
-        if (!response.ok) {
-            log(`Failed to fetch BigCommerce cart: ${String(response.status)}`, 'error');
-            return null;
-        }
-        const carts = (await response.json());
-        return (_b = (_a = carts === null || carts === void 0 ? void 0 : carts[0]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
-    }
-    catch (error) {
-        logError('Error fetching BigCommerce cart data', error);
-        return null;
-    }
-};
-/**
- * Fetch checkout data from the BigCommerce Storefront API.
- * This API is cookie-authenticated (same-origin), so no token is needed.
- */
-const fetchBigCommerceCheckout = async (checkoutId) => {
-    try {
-        const response = await fetch(`/api/storefront/checkouts/${checkoutId}`, {
-            credentials: 'same-origin',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-            },
-        });
-        if (!response.ok) {
-            log(`Failed to fetch BigCommerce checkout: ${String(response.status)}`, 'error');
-            return null;
-        }
-        return (await response.json());
-    }
-    catch (error) {
-        logError('Error fetching BigCommerce checkout data', error);
-        return null;
-    }
-};
 /**
  * Check if the logged-in user already has a shipping address on the checkout
- * that is internationally shippable. If so, save the address to session
- * and redirect to the home page to open the international checkout.
+ * that is internationally shippable. If so, optionally prompt the user to
+ * confirm before saving the address to session and redirecting to the home
+ * page to open the international checkout.
  */
-const checkLoggedInUserShippingAddress = async ({ onInternationalCheckoutSelected, }) => {
+const checkLoggedInUserShippingAddress = async ({ onInternationalCheckoutSelected, onLoggedInInternationalAddressDetected, }) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    // Check if the customer belongs to a bypass group (e.g. resellers) before
+    // redirecting them away from BigCommerce native checkout. This delegates to
+    // the shared helper so the bypass decision has a single source of truth and
+    // reuses the cached promise warmed by `initBigCommerceBypassCheck`.
+    const { shouldBypass } = await checkBigCommerceBypassCustomerGroup();
+    if (shouldBypass) {
+        return 'noAction';
+    }
     const checkoutId = await fetchCheckoutId();
     if (!checkoutId) {
-        return false;
+        return 'noAction';
     }
     const checkout = await fetchBigCommerceCheckout(checkoutId);
     const shippingAddress = (_b = (_a = checkout === null || checkout === void 0 ? void 0 : checkout.consignments) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.shippingAddress;
     if (!(shippingAddress === null || shippingAddress === void 0 ? void 0 : shippingAddress.countryCode)) {
-        return false;
+        return 'noAction';
     }
     const countryCode = shippingAddress.countryCode;
     if (!isShippableCountry(false, countryCode)) {
-        return false;
+        return 'noAction';
+    }
+    log(onLoggedInInternationalAddressDetected
+        ? `Logged-in user has international shipping address: ${countryCode}, prompting user to choose checkout`
+        : `Logged-in user has international shipping address: ${countryCode}, redirecting automatically (legacy behavior)`, 'info');
+    // Ask the consumer (zonos-checkout) whether to redirect or stay on BC.
+    // Without this prompt the user can get stuck in a redirect loop when their
+    // saved default address is international but they want to use a different
+    // (domestic) saved address in BigCommerce native checkout.
+    if (onLoggedInInternationalAddressDetected) {
+        const action = await onLoggedInInternationalAddressDetected();
+        if (action === 'stay') {
+            log('User opted to stay on BigCommerce native checkout despite international default address', 'info');
+            return 'optedOut';
+        }
     }
-    log(`Logged-in user has international shipping address: ${countryCode}, redirecting`, 'info');
     if (onInternationalCheckoutSelected) {
         await onInternationalCheckoutSelected();
     }
@@ -97,20 +72,24 @@ const checkLoggedInUserShippingAddress = async ({ onInternationalCheckoutSelecte
         state: (_k = shippingAddress.stateOrProvince) !== null && _k !== void 0 ? _k : '',
     });
     // Redirect to home page — the home page will open the international checkout
-    // when it detects the domestic shipping session
-    window.location.href = '/';
-    return true;
+    // when it detects the domestic shipping session. Carry over zonosQaUrl /
+    // zonosTestMode so the destination page keeps using the same build/env.
+    window.location.href = buildBigcommerceRedirectUrl('/');
+    return 'redirected';
 };
 /**
  * Watch for changes in domestic checkout step. Redirects user to home page to open international checkout when user selects a country in the international shipping zone.
  * @note Only works on default bigcommerce checkout page
  */
-export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedirectedBtnSelector, onInternationalCheckoutSelected, onShippingAddressSessionFound, }) => {
+export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedirectedBtnSelector, onInternationalCheckoutSelected, onLoggedInInternationalAddressDetected, onShippingAddressSessionFound, }) => {
     if (!window.Zonos.isBigCommerce) {
         return;
     }
     /**
-     * Keep checking
+     * Keep checking.
+     * @returns `true` if the caller should stop polling — either because the user
+     * is being redirected to Zonos international checkout, or because the
+     * logged-in customer is in a bypass group and should stay on BC checkout.
      */
     const handleInternationalCheckoutSelected = async (overrideShippingCountry) => {
         var _a;
@@ -126,6 +105,19 @@ export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedi
             // do nothing if shipping country is not shippable
             return false;
         }
+        // Only check bypass after confirming the country is shippable (i.e. user is
+        // about to be redirected to Zonos international checkout). Force-refresh so
+        // we re-fetch BigCommerce checkout data every time the ship-to country
+        // changes — prevents stale customer-group data from a cached fetch.
+        const { shouldBypass } = await checkBigCommerceBypassCustomerGroup({
+            forceRefresh: true,
+        });
+        if (shouldBypass) {
+            // Logged-in customer is in a bypass group — keep them on BC native
+            // checkout and stop polling / fetching further.
+            log('Bypass customer group detected on BC checkout, stopping interval', 'info');
+            return true;
+        }
         if (onInternationalCheckoutSelected) {
             await onInternationalCheckoutSelected();
         }
@@ -157,13 +149,40 @@ export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedi
             postalCode: shippingAddress.postalCode,
             state: shippingAddress.stateOrProvince,
         });
-        // redirect to home page, home page then will open the checkout dialog if having domestic shipping session
-        window.location.href = '/';
+        // redirect to home page, home page then will open the checkout dialog if
+        // having domestic shipping session. Carry over zonosQaUrl / zonosTestMode
+        // so the destination page keeps using the same build/env.
+        window.location.href = buildBigcommerceRedirectUrl('/');
         return true;
     };
     let isProcessing = false;
     let intervalCreated = false;
     let isCheckingLoggedInUserShippingAddress = false;
+    /**
+     * Set to `true` once the logged-in user has been prompted about a detected
+     * international default address and chose to stay on the BigCommerce native
+     * checkout. Prevents the observer from re-prompting on subsequent DOM
+     * mutations.
+     */
+    let loggedInAddressCheckSkipped = false;
+    /**
+     * Set to `true` while the logged-in international-address confirmation
+     * dialog is open and we are awaiting the user's response. While this
+     * flag is set the polling interval must not call
+     * `handleInternationalCheckoutSelected` — otherwise the interval would
+     * detect the pre-filled international country, show the loading dialog,
+     * and redirect before the user has responded to the confirm prompt.
+     */
+    let isAwaitingLoggedInConfirmation = false;
+    // NOTE: We intentionally do NOT await `checkBigCommerceBypassCustomerGroup()`
+    // here before attaching the MutationObserver. The bypass check involves two
+    // Storefront API round-trips, and awaiting it synchronously would delay
+    // observer registration — on fast-rendering BC pages that window can cause
+    // us to miss the initial DOM mutations and never trigger the redirect.
+    // Bypass is already enforced inside `checkLoggedInUserShippingAddress` and
+    // `handleInternationalCheckoutSelected` (both consult the helper), so the
+    // top-level gate is redundant. `initBigCommerceBypassCheck()` is called on
+    // page load so those inner calls typically resolve against a warm cache.
     const observer = new MutationObserver(async () => {
         var _a;
         const domesticRedirectedButton = document.querySelector(domesticRedirectedBtnSelector);
@@ -190,24 +209,35 @@ export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedi
         // For logged-in users, check if their saved address on the checkout is international
         // before the shipping form is even rendered.
         // Guard against repeated calls — the observer fires on every DOM mutation.
-        if (isCheckingLoggedInUserShippingAddress) {
-            return;
-        }
-        isCheckingLoggedInUserShippingAddress = true;
-        try {
-            const redirected = await checkLoggedInUserShippingAddress({
-                onInternationalCheckoutSelected,
-            });
-            if (redirected) {
-                observer.disconnect();
-                return;
+        // Also skip if the user already chose to stay on BC native checkout.
+        if (!loggedInAddressCheckSkipped &&
+            !isCheckingLoggedInUserShippingAddress) {
+            isCheckingLoggedInUserShippingAddress = true;
+            isAwaitingLoggedInConfirmation = true;
+            try {
+                const result = await checkLoggedInUserShippingAddress({
+                    onInternationalCheckoutSelected,
+                    onLoggedInInternationalAddressDetected,
+                });
+                if (result === 'redirected') {
+                    observer.disconnect();
+                    return;
+                }
+                if (result === 'optedOut') {
+                    // User elected to stay on BC native checkout — don't prompt again
+                    // for the rest of this session. Continue with the rest of the
+                    // observer logic so the country-change watcher still fires when
+                    // the user manually picks an international country in BC's UI.
+                    loggedInAddressCheckSkipped = true;
+                }
+            }
+            catch (error) {
+                logError('Error checking logged-in user shipping address', error);
+            }
+            finally {
+                isCheckingLoggedInUserShippingAddress = false;
+                isAwaitingLoggedInConfirmation = false;
             }
-        }
-        catch (error) {
-            logError('Error checking logged-in user shipping address', error);
-        }
-        finally {
-            isCheckingLoggedInUserShippingAddress = false;
         }
         const shipToCountryElement = document.querySelector(((_a = zonosStore.genericSettings) === null || _a === void 0 ? void 0 : _a.bigcommerceDomesticCheckoutCountrySelector) ||
             FALLBACK_SHIP_TO_COUNTRY_SELECTOR);
@@ -227,14 +257,18 @@ export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedi
         // disconnect the observer after we know that's bigcommerce domestic checkout page
         observer.disconnect();
         const interval = setInterval(async () => {
-            if (isProcessing) {
+            // Don't redirect while the logged-in international-address confirm
+            // dialog is open — the user hasn't made their choice yet.
+            if (isProcessing || isAwaitingLoggedInConfirmation) {
                 return;
             }
             isProcessing = true;
             try {
-                const isInternationalCountrySelected = await handleInternationalCheckoutSelected();
-                // When isInternationalCountrySelected is true, user will be redirected shortly, so we can stop the checking interval here
-                if (isInternationalCountrySelected) {
+                const shouldStopPolling = await handleInternationalCheckoutSelected();
+                // Stop the interval once either:
+                //  - the user is being redirected to Zonos international checkout
+                //  - the logged-in customer is in a bypass group (stay on BC checkout)
+                if (shouldStopPolling) {
                     clearInterval(interval);
                     return;
                 }
@@ -258,7 +292,7 @@ export const watchImmediateBigcommerceDomesticCheckoutRedirect = ({ domesticRedi
             clearInterval(stripeBcListenerInterval);
             addressElement.on('change', event => {
                 const shippingCountry = event.value.address.country;
-                if (shippingCountry) {
+                if (shippingCountry && !isAwaitingLoggedInConfirmation) {
                     void handleInternationalCheckoutSelected(shippingCountry);
                 }
             });

package/dist/esm/{cart-394c9ddb.js → cart-55b8dd7c.js}

@@ -1,5 +1,5 @@
 import { c as createStore, z as zonosStore } from './zonosStore-5242a58d.js';
-import { s as storageStore, l as localizationStore, e as getOverridenZCountry, t as translate, f as filterValidTests, b as storageStoreSetEnabledVariantTestKeys } from './localization-0ebc8356.js';
+import { s as storageStore, l as localizationStore, e as getOverridenZCountry, t as translate, f as filterValidTests, b as storageStoreSetEnabledVariantTestKeys } from './localization-d11c973f.js';
 import { l as log, b as allLogs } from './VarianceTest-572cecf5.js';
 import { h as handleFetch, l as logError, f as fallbackApiList, g as getIsTestMode, a as getIsStagingMode, s as sendErrorLog, j as jsonParse } from './handleFetch-a844cac1.js';
 import { i as isDarkColor } from './isDarkColor-3537021b.js';

package/dist/esm/{hasInclusivePrice-f0322e1c.js → hasInclusivePrice-ddae18fd.js}

@@ -1,4 +1,4 @@
-import { l as localizationStore } from './localization-0ebc8356.js';
+import { l as localizationStore } from './localization-d11c973f.js';
 
 /**
  * Since the backend and the frontend are using the same keys,

package/dist/esm/index.js

@@ -131,7 +131,7 @@ const getZonosQaUrl = () => {
         return null;
     }
     const qaUrl = extractZonosQaUrl(window.location.href);
-    const cdnUrl = "https://v1.3.254.js.zonos.com";
+    const cdnUrl = "https://v1.3.256.js.zonos.com";
     // when the qaUrl is not set and the built URL is from the test domain, use the test domain for testing
     if (!qaUrl &&
         (cdnUrl.includes('test.') ||
@@ -379,10 +379,10 @@ const zonosLoadUrl = (() => {
     return null;
 })();
 const startLoadTime = Date.now();
-const ZONOS_URL = "https://v1.3.254.js.zonos.com";
-const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.254";
-const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.254";
-const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.254";
+const ZONOS_URL = "https://v1.3.256.js.zonos.com";
+const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.256";
+const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.256";
+const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.256";
 const GOOGLE_FONT_URL = 'https://fonts.googleapis.com';
 const GOOGLE_FONT_REGEX = /^https:\/\/fonts\.googleapis\.com/;
 class Zonos {
@@ -400,7 +400,7 @@ Zonos.iframeLogType = typeof window !== 'undefined'
     ? new URLSearchParams(window.location.search).get('iframeLogType')
     : null;
 Zonos.isBigCommerce = false;
-Zonos.releaseDate = "1776274345662";
+Zonos.releaseDate = "1776369543866";
 Zonos.isLegacyCheckout = false;
 Zonos.googleAnalyticId = null;
 Zonos.googleAnalyticReady = false;
@@ -423,7 +423,7 @@ Zonos.isNpm = true;
 Zonos.zonosQaUrl = null;
 Zonos.zonosQaUrlApi = null;
 Zonos.trackEventLogs = [];
-Zonos.version = `v${"1.3.254"}`;
+Zonos.version = `v${"1.3.256"}`;
 Zonos.modeAlerted = false;
 Zonos.cartData = null;
 Zonos.paypal = null;

package/dist/esm/{invoice-5ae81ae5.js → invoice-dbe85a18.js}

@@ -1,6 +1,6 @@
 import { c as createStore, z as zonosStore } from './zonosStore-5242a58d.js';
-import { b as stripeStore, G as stripeStoreBuildAddressForPartyCreate, d as cartStore, H as cartStoreUpdateSelectedShippingOption } from './cart-394c9ddb.js';
-import { s as storageStore } from './localization-0ebc8356.js';
+import { b as stripeStore, G as stripeStoreBuildAddressForPartyCreate, d as cartStore, H as cartStoreUpdateSelectedShippingOption } from './cart-55b8dd7c.js';
+import { s as storageStore } from './localization-d11c973f.js';
 import { h as handleFetch, s as sendErrorLog, l as logError } from './handleFetch-a844cac1.js';
 import { b as allLogs } from './VarianceTest-572cecf5.js';
 

package/dist/esm/{isCollectMobileTablet-15b668d6.js → isCollectMobileTablet-8af0d16d.js}

@@ -1,6 +1,6 @@
 import { c as createStore, z as zonosStore } from './zonosStore-5242a58d.js';
-import { b as stripeStore, G as stripeStoreBuildAddressForPartyCreate, d as cartStore, H as cartStoreUpdateSelectedShippingOption } from './cart-394c9ddb.js';
-import { s as storageStore } from './localization-0ebc8356.js';
+import { b as stripeStore, G as stripeStoreBuildAddressForPartyCreate, d as cartStore, H as cartStoreUpdateSelectedShippingOption } from './cart-55b8dd7c.js';
+import { s as storageStore } from './localization-d11c973f.js';
 import { h as handleFetch, s as sendErrorLog, l as logError } from './handleFetch-a844cac1.js';
 import { b as allLogs } from './VarianceTest-572cecf5.js';