@zonos/elements 1.3.51 → 1.3.53

package/dist/cjs/{createCustomEvent-9b91480b.js → createCustomEvent-228027b5.js}

@@ -1,7 +1,8 @@
 'use strict';
 
-const cart = require('./cart-546d1602.js');
+const cart = require('./cart-61a8983d.js');
 const zonosStore = require('./zonosStore-67139f0e.js');
+const handleFetch = require('./handleFetch-842c95b0.js');
 
 const trackConversionEvent = async (eventName, metadata) => {
     var _a, _b;
@@ -29,7 +30,7 @@ const trackConversionEvent = async (eventName, metadata) => {
         metadata,
         organizationId,
     };
-    await cart.handleFetch('/api/zonos-elements/track-conversion-event', {
+    await handleFetch.handleFetch('/api/zonos-elements/track-conversion-event', {
         body,
         method: 'POST',
     });

package/dist/cjs/handleFetch-842c95b0.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const log = (message, type, ...additionalInfo) => {
+    var _a, _b;
+    const isDebug = !!((_a = window.Zonos) === null || _a === void 0 ? void 0 : _a.debug) ||
+        !!window.location.search.match(/\?.*(&*)zonosDebug=1/);
+    // if debug is false, do not log
+    if (!isDebug) {
+        // log errors to the console if the type is error
+        if (type === 'error') {
+            // eslint-disable-next-line no-console
+            console.error(message, ...additionalInfo);
+        }
+        return;
+    }
+    let loggingIframe = document.querySelector('iframe#zonos---debug-logging-iframe');
+    if (!loggingIframe) {
+        // add a hidden iframe
+        loggingIframe = document.createElement('iframe');
+        loggingIframe.id = 'zonos---debug-logging-iframe';
+        loggingIframe.style.display = 'none';
+        loggingIframe.style.opacity = '0';
+        loggingIframe.style.position = 'absolute';
+        loggingIframe.style.top = '-9999px';
+        loggingIframe.style.left = '-9999px';
+        loggingIframe.style.width = '1px';
+        loggingIframe.style.height = '1px';
+        loggingIframe.style.border = 'none';
+        loggingIframe.style.overflow = 'hidden';
+        loggingIframe.style.visibility = 'hidden';
+        document.body.appendChild(loggingIframe);
+    }
+    // use the logging iframe's console to log just in case the console is disabled (overriden) by the site owner
+    const zConsole = ((_b = loggingIframe.contentWindow) === null || _b === void 0 ? void 0 : _b.window.console) || window.console;
+    switch (type) {
+        case 'warn':
+            zConsole.warn(message, ...additionalInfo);
+            break;
+        case 'info':
+            zConsole.info(message, ...additionalInfo);
+            break;
+        case 'error':
+            zConsole.error(message, ...additionalInfo);
+            break;
+        default:
+            zConsole.groupCollapsed(message, ...additionalInfo);
+            zConsole.trace();
+            zConsole.groupEnd();
+            break;
+    }
+};
+
+const logError = (message, ...rest) => {
+    log(message, 'error', ...rest);
+};
+
+const fallbackApiType = ['cloudflare', 'vercel'];
+const MAIN_BASE_API_TYPE = fallbackApiType[0];
+const fallbackApiList = {
+    cloudflare: "https://route.elements.zonos.com",
+    vercel: "https://v1.route.js.zonos.com",
+};
+const MAIN_BASE_API = fallbackApiList[MAIN_BASE_API_TYPE];
+/**
+ * Next available fallback api type
+ */
+const getNextFallbackApiType = (currentApiType = MAIN_BASE_API_TYPE) => {
+    const currentIndex = fallbackApiType.indexOf(currentApiType);
+    const nextFallbackApiType = fallbackApiType[currentIndex + 1];
+    if (!nextFallbackApiType) {
+        return null;
+    }
+    return nextFallbackApiType;
+};
+
+const jsonParse = (_data) => {
+    if (typeof _data === 'string') {
+        try {
+            // eslint-disable-next-line no-restricted-syntax
+            const json = JSON.parse(_data);
+            return json;
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    return null;
+};
+
+/**
+ * This is the time in milliseconds after release time that we will start sending error logs to the new API
+ * @default 1 hour
+ */
+const postReleaseReportingDuration = 1 * 3600 * 1000; // 1 hour
+const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostReleaseErrorReporting, }) => {
+    if (shouldPostReleaseErrorReporting) {
+        // We only want to report errors that happened if current time is less than 2 hours after release time
+        const releaseTime = Number(window.Zonos.releaseDate);
+        const currentTime = new Date().getTime();
+        if (currentTime - releaseTime > postReleaseReportingDuration) {
+            return;
+        }
+    }
+    const userAgentData = 'userAgentData' in window.navigator
+        ? // userAgentData is not yet supported in all browsers
+            window.navigator.userAgentData
+        : null;
+    const errorObject = {
+        endpoint,
+        errors,
+        metadata: Object.assign({ href: window.location.href, userAgent: userAgentData && userAgentData.brands.length > 0
+                ? userAgentData
+                : window.navigator.userAgent }, metadata),
+    };
+    try {
+        // use native fetch because in handleFetch also calls sendErrorLog and it will possibly cause circular dependencies issue
+        void fetch(`${MAIN_BASE_API}/api/zonos-elements/log-error`, {
+            body: JSON.stringify(errorObject),
+            method: 'POST',
+        });
+    }
+    catch (_err) {
+        const nextFallbackApi = getNextFallbackApiType();
+        if (!nextFallbackApi) {
+            return;
+        }
+        // request to the fallback API if the first one fails
+        void fetch(`${fallbackApiList[nextFallbackApi]}/api/zonos-elements/log-error`, {
+            body: JSON.stringify(errorObject),
+            method: 'POST',
+        });
+    }
+};
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+const getResponseBody = async ({ response, shouldLog = true, shouldThrow = false, }) => {
+    try {
+        const json = await response.json();
+        return json;
+    }
+    catch (e) {
+        if (shouldThrow) {
+            throw e;
+        }
+        if (shouldLog) {
+            // eslint-disable-next-line
+            console.error(e);
+        }
+        return null;
+    }
+};
+const encodeString = (text) => {
+    try {
+        // encode the string, remove the "=" at the end of the encoded string
+        const encodedString = btoa(text).replace(/=/g, '');
+        return encodedString;
+    }
+    catch (error) {
+        // return the reverse string if the encoding failed
+        return text
+            .replace(/[^A-Za-z0-9]/g, '')
+            .split('')
+            .reverse()
+            .join('');
+    }
+};
+const handleRequest = async ({ basePathType, options, path, }) => {
+    let response;
+    // fallback to the main base API if the passed in base path is not available
+    const baseUrl = fallbackApiList[basePathType] || MAIN_BASE_API_TYPE;
+    const url = baseUrl + path;
+    // adding random encoded token to the url so that the request will be cached differently for each store
+    const modifiedUrl = new URL(url);
+    modifiedUrl.searchParams.set('zToken', encodeString(window.location.hostname));
+    try {
+        response = await fetch(modifiedUrl.toString(), options);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return {
+                baseUrl,
+                errors: [{ message: e.message, type: 'unknown' }],
+                json: null,
+                response: null,
+                zonosMode: null,
+            };
+        }
+        const message = 'Fail to fetch';
+        return {
+            baseUrl,
+            errors: [{ message, type: 'unknown' }],
+            json: null,
+            response: null,
+            zonosMode: null,
+        };
+    }
+    const zonosMode = response.headers.get('Zonos-Mode');
+    const usingZonosPreview = window.Zonos.zonosQaUrl;
+    // We only want to alert once if the user is in preview mode and it's also using production environment
+    if (!window.Zonos.modeAlerted && zonosMode && usingZonosPreview) {
+        window.Zonos.modeAlerted = true;
+    }
+    if (response.ok) {
+        const data = await getResponseBody({ response });
+        return {
+            baseUrl,
+            errors: [],
+            json: data,
+            response,
+            zonosMode,
+        };
+    }
+    const status = response.status.toString();
+    try {
+        const data = await getResponseBody({
+            response,
+            shouldThrow: true,
+        });
+        const message = JSON.stringify(data);
+        return {
+            baseUrl,
+            errors: [{ message, type: status }],
+            json: null,
+            response,
+            zonosMode,
+        };
+    }
+    catch (e) {
+        const message = 'Unknown error';
+        return {
+            baseUrl,
+            errors: [{ message: `${status}: ${message}`, type: status }],
+            json: null,
+            response: null,
+            zonosMode,
+        };
+    }
+};
+const handleRequestWithFallback = async ({ basePathType: _basePathType, options, path, }) => {
+    var _a, _b;
+    // use vercel API if the path is `/api/bigcommerce`
+    const isBigcommerceEndpoint = path.startsWith('/api/bigcommerce');
+    const basePathType = isBigcommerceEndpoint
+        ? 'vercel'
+        : _basePathType;
+    const _c = await handleRequest({
+        basePathType,
+        options,
+        path,
+    }), { errors, response } = _c, rest = __rest(_c, ["errors", "response"]);
+    const nextFallbackApiType = getNextFallbackApiType(basePathType);
+    const unknownError = errors.find(({ type }) => type === 'unknown');
+    const isUnknownError = !!unknownError || (response === null || response === void 0 ? void 0 : response.status) === 404;
+    const shouldCallFallback = 
+    // If next fallback is available, and the error is unknown (fail to fetch) or 404
+    nextFallbackApiType && isUnknownError;
+    // Should log the error if it's unknown error
+    if (isUnknownError) {
+        void sendErrorLog({
+            endpoint: fallbackApiList[basePathType] + path,
+            errors: errors.map(({ message }) => message),
+            metadata: {
+                currentBasePath: basePathType,
+                nextFallbackApiType,
+                requestHeaders: options === null || options === void 0 ? void 0 : options.headers,
+                requestPayload: jsonParse((_a = options === null || options === void 0 ? void 0 : options.body) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = options === null || options === void 0 ? void 0 : options.body) === null || _b === void 0 ? void 0 : _b.toString()),
+                status: response === null || response === void 0 ? void 0 : response.status,
+                statusText: response === null || response === void 0 ? void 0 : response.statusText,
+            },
+            // When the error is unknown, error reporting should be enabled for period of time after release, so we can monitor the error.
+            shouldPostReleaseErrorReporting: true,
+        });
+    }
+    if (shouldCallFallback) {
+        log(`=== "${path}" failed to fetch, trying next fallback ${nextFallbackApiType}`);
+        return handleRequestWithFallback({
+            basePathType: nextFallbackApiType,
+            options,
+            path,
+        });
+    }
+    // No more fallbacks, just return the result
+    return Object.assign({ errors, response }, rest);
+};
+/**
+ * Fetch request and will request to fallback API when the first one fails
+ * @param path Path name of the request (e.g. /api/something/com).
+ * @param _opts fetch options
+ */
+const handleFetch = async (path, _opts) => {
+    const opts = __rest(_opts || {}, []);
+    const body = opts.body ? JSON.stringify(opts.body) : undefined;
+    const method = opts.method || 'GET';
+    // headers content type
+    const headers = Object.assign({ 'Content-Type': 'application/json', 'Zonos-Is-BigCommerce': window.Zonos.isBigCommerce.toString(), 'Zonos-Referer': window.location.hostname, 'Zonos-Version': window.Zonos.version, credentialtoken: window.Zonos.zonosApiKey || 'Empty credential token from zonos-elements' }, opts.headers);
+    const options = Object.assign(Object.assign({}, opts), { body: method === 'GET' ? undefined : body, headers,
+        method });
+    // This is for testing fallback API, set fallback API type to start with
+    const useFallbackApi = new URLSearchParams(window.location.search).get('useFallbackApi');
+    return handleRequestWithFallback({
+        basePathType: useFallbackApi || MAIN_BASE_API_TYPE,
+        options,
+        path,
+    });
+};
+
+exports.fallbackApiList = fallbackApiList;
+exports.handleFetch = handleFetch;
+exports.jsonParse = jsonParse;
+exports.log = log;
+exports.logError = logError;
+exports.sendErrorLog = sendErrorLog;

package/dist/cjs/index.cjs.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const logError = require('./logError-4e2f2020.js');
+const handleFetch = require('./handleFetch-842c95b0.js');
+const CheckoutConfig = require('./CheckoutConfig-65376e00.js');
 
 /**
  * Get the load version and url based on the loadScriptSrc and version
@@ -41,6 +42,7 @@ const checkIfLoadVersionDomain = ({ loadScriptSrc }) => {
 };
 
 const fallbackList = ['jsdelivr', 'cdnjs', 'unpkg', 'vercel'];
+const MAIN_LOAD_CDN_TYPE = 'jsdelivr';
 /**
  * Get the next cdn type in the fallback list
  * @param currentCdnType The current cdn type that want to get the next fallback url
@@ -94,7 +96,7 @@ const getZonosQaUrl = () => {
         return null;
     }
     const qaUrl = extractZonosQaUrl(window.location.href);
-    const cdnUrl = "https://v1.3.51.js.zonos.com";
+    const cdnUrl = "https://v1.3.53.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.') ||
@@ -116,7 +118,7 @@ const getZonosQaUrl = () => {
     }
     const suffixDomain = 'preview.js.zonos.com';
     const fullUrl = `https://${qaUrl}.${suffixDomain}`;
-    logError.log(`[ZONOS-WARNING] using '${fullUrl}' for loading script`, 'warn');
+    handleFetch.log(`[ZONOS-WARNING] using '${fullUrl}' for loading script`, 'warn');
     // request to the url and check if the request has an error
     void fetch(fullUrl)
         .then(() => {
@@ -167,7 +169,7 @@ const injectScript = (params) => {
     script.src = `${V3_URL}${queryString}`;
     const headBody = document.head || document.body;
     if (!headBody) {
-        logError.logError('Expected document.body not to be null. Stripe.js requires a <body> element.');
+        handleFetch.logError('Expected document.body not to be null. Stripe.js requires a <body> element.');
         return null;
     }
     headBody.appendChild(script);
@@ -251,6 +253,16 @@ const zonosLoadStripe = async (...args) => {
     return stripePromise.then(maybeStripe => initStripe(maybeStripe, args, startTime));
 };
 
+const TEMP_CART_ID_QUERY_PARAM = 'tempCartUUID';
+/**
+ * Simple function to get the cart id from the query param.
+ */
+const getCartIdFromQueryParam = () => {
+    const urlParams = new URLSearchParams(window.location.search);
+    const cartId = urlParams.get(TEMP_CART_ID_QUERY_PARAM);
+    return cartId;
+};
+
 var _a;
 /**
  * Get the load version and url based on the loadScriptSrc, if the domain that used to load `zonos.js` is in white listed domains, use currentLoadScriptUrl as the load url instead, if zonosQaUrl exists, it would also fall under the white listed domain
@@ -268,11 +280,10 @@ const zonosLoadUrl = (() => {
     }
     return null;
 })();
-const ZONOS_URL = "https://v1.3.51.js.zonos.com";
-const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.51";
-const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.51";
-const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.51";
-const MAIN_LOAD_CDN_TYPE = 'jsdelivr';
+const ZONOS_URL = "https://v1.3.53.js.zonos.com";
+const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.3.53";
+const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.3.53";
+const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.3.53";
 const INTER_FONT_URL = 'https://rsms.me';
 const GOOGLE_FONT_URL = 'https://fonts.googleapis.com';
 const INTER_FONT_REGEX = /^https:\/\/rsms\.me\/inter\/inter\.css(.*)$/;
@@ -287,31 +298,59 @@ Zonos.zonosConversionTest = typeof window !== 'undefined' &&
     !!window.location.search.match(/\?.*(&*)zonosConversionTest/);
 Zonos._paypalMockResponse = null;
 Zonos.isBigCommerce = false;
-Zonos.releaseDate = "1726523859808";
+Zonos.releaseDate = "1726614519273";
+Zonos.isLegacyCheckout = false;
 /**
  * By default, the package will load from npm
  */
 Zonos.isNpm = true;
 Zonos.zonosQaUrl = null;
-Zonos.version = `v${"1.3.51"}`;
+Zonos.version = `v${"1.3.53"}`;
 Zonos.modeAlerted = false;
-Zonos.tempCartData = null;
+Zonos.cartData = null;
 Zonos.paypal = null;
 Zonos.getCurrentTimestamp = () => new Date().getTime();
 Zonos.zonosController = null;
 Zonos.init = async ({ appearance, checkoutSettings, currencyConverter, helloSettings, onCountryChange, overrideCurrencyFormat, storeId, zonosApiKey, }) => {
+    _a.cartId = getCartIdFromQueryParam();
     if (_a.doneInit) {
         // do nothing if zonos is already initializeds
         return;
     }
-    logError.log(`====== ZONOS DEBUG MODE: on (${_a.version}) ======`);
-    if (!zonosApiKey) {
-        logError.logError('Missing Zonos API key');
-        return;
-    }
+    handleFetch.log(`====== ZONOS DEBUG MODE: on (${_a.version}) ======`);
     _a.zonosApiKey = zonosApiKey;
     _a.storeId = storeId;
-    logError.log('init zonos');
+    if (_a.isNpm) {
+        handleFetch.log('====== ZONOS LOADING FROM NPM ======');
+        // zonosApiKey is required if tempCartUUID in query params are not provided
+        if (!zonosApiKey && !_a.cartId) {
+            handleFetch.logError('Zonos API key is required unless `tempCartUUID` is provided in url query params.');
+            return;
+        }
+        /**
+         * This is mainly for user that integrates Zonos with npm
+         * If cartUUID is provided in query param and cartData is not available, get and initialize cart data to prepare to open checkout right away
+         */
+        if (!_a.cartData && _a.cartId) {
+            handleFetch.log('Initialize cart data');
+            const params = await CheckoutConfig.setupCartData(_a.cartId);
+            if (!params) {
+                handleFetch.logError('Failed to get cart data');
+                return;
+            }
+            _a.cartData = params.cartData;
+            _a.zonosApiKey = params.zonosApiKey;
+        }
+    }
+    // inject hidden button to body to trigger checkout right away if we have cartData
+    if (_a.cartId && _a.cartData) {
+        handleFetch.log('Cart data is available, inject hidden button and trigger checkout');
+        const hiddenButton = document.createElement('button');
+        hiddenButton.style.display = 'none';
+        hiddenButton.id = `${CheckoutConfig.checkoutHiddenBtnSelector}`;
+        document.body.appendChild(hiddenButton);
+    }
+    handleFetch.log('init zonos');
     // inject zonos cdn
     _a.injectZonosCdn();
     // inject css for zonos elements
@@ -328,7 +367,6 @@ Zonos.init = async ({ appearance, checkoutSettings, currencyConverter, helloSett
             onCountryChange,
             overrideCurrencyFormat,
         },
-        zonosApiKey,
     });
     _a.doneInit = true;
 };
@@ -400,7 +438,7 @@ Zonos.disablePlaceOrderButtons = ({ autoEnable = true, config, disable, placeOrd
         }
     }
 };
-Zonos.injectController = ({ config, zonosApiKey, }) => {
+Zonos.injectController = ({ config, }) => {
     var _b;
     if (document.querySelector('zonos-controller')) {
         return;
@@ -428,13 +466,13 @@ Zonos.injectController = ({ config, zonosApiKey, }) => {
     }
     const zonosController = document.createElement('zonos-controller');
     zonosController.config = config;
-    zonosController.zonosApiKey = zonosApiKey;
+    zonosController.zonosApiKey = _a.zonosApiKey || '';
     zonosController.addEventListener('stripeInitEvent', async (event) => {
         const { detail } = event;
-        logError.log('loading Stripe');
+        handleFetch.log('loading Stripe');
         const stripe = await zonosLoadStripe(detail.publishableKey);
         if (!stripe) {
-            logError.logError('API seems to be invalid or missing. Failed to load Stripe');
+            handleFetch.logError('API seems to be invalid or missing. Failed to load Stripe');
             return;
         }
         window.Zonos.stripe = stripe;
@@ -443,7 +481,7 @@ Zonos.injectController = ({ config, zonosApiKey, }) => {
     document.body.appendChild(zonosController);
     // set zonos controller to be global
     _a.zonosController = zonosController;
-    logError.log('Zonos controller injected!');
+    handleFetch.log('Zonos controller injected!');
 };
 Zonos.injectScript = ({ cdnType, isModule, theRestUrl, }) => {
     const scriptDomain = _a.getZonosUrl(cdnType);
@@ -453,7 +491,7 @@ Zonos.injectScript = ({ cdnType, isModule, theRestUrl, }) => {
         return !!script;
     };
     if (findScript()) {
-        logError.log(`Zonos script "${fullScriptUrl}" already exists in the document`, 'warn');
+        handleFetch.log(`Zonos script "${fullScriptUrl}" already exists in the document`, 'warn');
         return;
     }
     const headOrBody = document.head || document.body;
@@ -469,7 +507,7 @@ Zonos.injectScript = ({ cdnType, isModule, theRestUrl, }) => {
     script.src = fullScriptUrl;
     script.crossOrigin = 'anonymous';
     script.onerror = () => {
-        logError.logError(`Failed to load ${script.src}`);
+        handleFetch.logError(`Failed to load ${script.src}`);
         const nextFallbackCdnType = getNextFallbackUrl(cdnType);
         // if next fallback cdn type exists, inject the script with the next fallback cdn type
         if (!nextFallbackCdnType) {
@@ -521,7 +559,7 @@ Zonos.injectZonosCdn = () => {
         isModule: false,
         theRestUrl: 'dist/zonos-elements/zonos-elements.js',
     });
-    logError.log('Zonos cdn script injected!');
+    handleFetch.log('Zonos cdn script injected!');
 };
 Zonos.injectStylesheet = ({ cdnType, theRestUrl, }) => {
     const stylesheetDomain = _a.getZonosUrl(cdnType);
@@ -536,7 +574,7 @@ Zonos.injectStylesheet = ({ cdnType, theRestUrl, }) => {
     zonosCss.rel = 'stylesheet';
     zonosCss.href = `${stylesheetDomain}/${theRestUrl}`;
     zonosCss.onerror = () => {
-        logError.logError(`Failed to load ${zonosCss.href}`);
+        handleFetch.logError(`Failed to load ${zonosCss.href}`);
         const nextFallbackCdnType = getNextFallbackUrl(cdnType);
         // if the css failed to load, try to load the next fallback cdn if exists
         if (!nextFallbackCdnType) {
@@ -554,7 +592,7 @@ Zonos.injectZonosCss = () => {
         return !!document.querySelector(`link[rel="stylesheet"][href*="/dist/zonos-elements/zonos-elements.css"]`);
     };
     if (findStyleLink()) {
-        logError.log('Zonos style links already injected', 'warn');
+        handleFetch.log('Zonos style links already injected', 'warn');
         return;
     }
     // inject css for zonos elements
@@ -562,7 +600,7 @@ Zonos.injectZonosCss = () => {
         cdnType: MAIN_LOAD_CDN_TYPE,
         theRestUrl: 'dist/zonos-elements/zonos-elements.css',
     });
-    logError.log('Zonos style css injected!');
+    handleFetch.log('Zonos style css injected!');
 };
 Zonos.injectFonts = () => {
     const findFont = () => {
@@ -580,7 +618,7 @@ Zonos.injectFonts = () => {
         return null;
     };
     if (findFont()) {
-        logError.log('Inter font already injected', 'warn');
+        handleFetch.log('Inter font already injected', 'warn');
         return;
     }
     const headOrBody = document.head || document.body;
@@ -594,7 +632,7 @@ Zonos.injectFonts = () => {
     font.rel = 'stylesheet';
     font.href = `${INTER_FONT_URL}/inter/inter.css`;
     headOrBody.appendChild(font);
-    logError.log('Zonos font injected!');
+    handleFetch.log('Zonos font injected!');
 };
 // apply font for zonos elements and inject font if needed
 Zonos.setupGoogleFont = (fontFamily) => {
@@ -604,7 +642,7 @@ Zonos.setupGoogleFont = (fontFamily) => {
 // this function is to inject google font to the browser, not apply the font for zonos elements, to apply the font and inject font if needed, use `setupGoogleFont` instead
 Zonos.injectSupportGoogleFont = (fontUrl) => {
     var _b;
-    logError.log(`[FONT] injecting ${fontUrl}`);
+    handleFetch.log(`[FONT] injecting ${fontUrl}`);
     const fontFamily = (_b = fontUrl.match(/family=(.*?):/)) === null || _b === void 0 ? void 0 : _b[1];
     const headOrBody = document.head || document.body;
     // inject font css for zonos elements
@@ -615,14 +653,16 @@ Zonos.injectSupportGoogleFont = (fontUrl) => {
         headOrBody.appendChild(customFontPreconnect);
     }
     if (document.querySelector(`link[rel="stylesheet"][href="${fontUrl}"]`)) {
-        logError.log(`[FONT] ${fontFamily} font already injected`, 'warn');
+        handleFetch.log(`[FONT] ${fontFamily} font already injected`, 'warn');
         return;
     }
     const customFont = document.createElement('link');
     customFont.rel = 'stylesheet';
     customFont.href = fontUrl;
     headOrBody.appendChild(customFont);
-    logError.log(`[FONT] ${fontFamily} font injected!`);
+    handleFetch.log(`[FONT] ${fontFamily} font injected!`);
 };
 
+exports.checkoutHiddenBtnSelector = CheckoutConfig.checkoutHiddenBtnSelector;
+exports.domesticRedirectedBtnSelector = CheckoutConfig.domesticRedirectedBtnSelector;
 exports.Zonos = Zonos;