@zonos/elements 1.5.0 → 1.5.2

package/dist/esm/{handleFetch-D5GYDF-O.js → handleFetch-BFVO7oAR.js}

@@ -1,17 +1,5 @@
 import { l as log } from './VarianceTest-BJmZPrZl.js';
 
-const logError = (message, ...rest) => {
-    log(message, 'error', ...rest);
-};
-
-const getIsStagingMode = () => window.location.search.includes('zonosStagingMode=1');
-
-const getIsTestMode = () => {
-    var _a;
-    return ((_a = window.Zonos.zonosApiKey) === null || _a === void 0 ? void 0 : _a.includes('test')) ||
-        window.location.search.includes('zonosTestMode=1');
-};
-
 const fallbackApiType = ['cloudflare', 'vercel'];
 const MAIN_BASE_API_TYPE = fallbackApiType[0];
 const fallbackApiList = {
@@ -31,6 +19,164 @@ const getNextFallbackApiType = (currentApiType = MAIN_BASE_API_TYPE) => {
     return nextFallbackApiType;
 };
 
+/**
+ * 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 loggedHref = () => {
+    const url = new URL(window.location.href);
+    url.searchParams.delete('payment_intent');
+    url.searchParams.delete('payment_intent_client_secret');
+    url.searchParams.delete('redirect_status');
+    return url.toString();
+};
+const sendErrorLog = async ({ endpoint, errors, metadata, shouldPostReleaseErrorReporting, }) => {
+    log('sendErrorLog', 'warn', endpoint, metadata, errors);
+    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,
+        href: loggedHref(),
+        metadata: Object.assign({ appVersion: window.Zonos.version, domain: window.Zonos.domain, publicCredential: window.Zonos.zonosApiKey, 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),
+            headers: {
+                'Zonos-Referer': window.location.hostname,
+            },
+            method: 'POST',
+        });
+    }
+    catch (_a) {
+        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',
+        });
+    }
+};
+
+const thrownMessage = (error, fallback) => {
+    if (typeof error === 'string' && error) {
+        return error;
+    }
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string' &&
+        error.message) {
+        return error.message;
+    }
+    return fallback;
+};
+
+const logError = (message, ...rest) => {
+    log(message, 'error', ...rest);
+};
+
+const reportedIds = () => {
+    if (!window.__zonosReportedBlockedStorage) {
+        window.__zonosReportedBlockedStorage = new Set();
+    }
+    return window.__zonosReportedBlockedStorage;
+};
+/**
+ * Record a blocked storage read or write on the existing error log.
+ * A throw before `window.Zonos` exists is swallowed and does not use up
+ * the per-page dedupe slot, so the later startup read can still report it.
+ */
+const reportBlockedStorage = (area, operation, key, error) => {
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const dedupeId = `${area}\u0000${operation}\u0000${key}`;
+    const reported = reportedIds();
+    if (reported.has(dedupeId)) {
+        return;
+    }
+    reported.add(dedupeId);
+    void sendErrorLog({
+        endpoint: `storage://${area}/${key}`,
+        errors: [thrownMessage(error, 'SecurityError')],
+        metadata: {
+            area,
+            key,
+            operation,
+            shape: 'blocked-storage',
+        },
+    });
+};
+
+/**
+ * Touch `window.localStorage` / `window.sessionStorage` inside the try.
+ * Safari throws SecurityError on the getter itself when storage is blocked.
+ * A missing storage object is the same failure: calling `getItem` on it
+ * would report a TypeError instead of blocked storage.
+ */
+const storageFor = (area) => {
+    const storage = area === 'local' ? window.localStorage : window.sessionStorage;
+    if (!storage) {
+        throw new DOMException('', 'SecurityError');
+    }
+    return storage;
+};
+const safeGetItem = (area, key) => {
+    try {
+        return storageFor(area).getItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'getItem', key, error);
+        return null;
+    }
+};
+const safeRemoveItem = (area, key) => {
+    try {
+        storageFor(area).removeItem(key);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'removeItem', key, error);
+    }
+};
+const safeSetItem = (area, key, value) => {
+    try {
+        storageFor(area).setItem(key, value);
+    }
+    catch (error) {
+        reportBlockedStorage(area, 'setItem', key, error);
+    }
+};
+
+const getIsStagingMode = () => window.location.search.includes('zonosStagingMode=1');
+
+const getIsTestMode = () => {
+    var _a;
+    return ((_a = window.Zonos.zonosApiKey) === null || _a === void 0 ? void 0 : _a.includes('test')) ||
+        window.location.search.includes('zonosTestMode=1');
+};
+
 const jsonParse = (_data) => {
     if (typeof _data === 'string') {
         try {
@@ -133,56 +279,6 @@ const prepLoadTimeApiLog = ({ apiPath, apiType, loadTimeInternal, loadTimeTotal,
     window.Zonos.loadTimeApiInfoList.push(bulkLoadLogBody);
 };
 
-/**
- * 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, }) => {
-    log('sendErrorLog', 'warn', endpoint, metadata, errors);
-    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,
-        href: window.location.href,
-        metadata: Object.assign({ appVersion: window.Zonos.version, domain: window.Zonos.domain, publicCredential: window.Zonos.zonosApiKey, 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),
-            headers: {
-                'Zonos-Referer': window.location.hostname,
-            },
-            method: 'POST',
-        });
-    }
-    catch (_a) {
-        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)
@@ -195,6 +291,7 @@ var __rest = (undefined && undefined.__rest) || function (s, e) {
         }
     return t;
 };
+const isGatewayStatus = (status) => status === 502 || status === 503 || status === 504;
 const getResponseBody = async ({ response, shouldLog = true, shouldThrow = false, }) => {
     try {
         const text = await response.text();
@@ -315,28 +412,31 @@ const handleRequest = async ({ basePathType, options, path, }) => {
     }
     catch (_a) {
         const message = 'Unknown error';
+        // A gateway HTML or empty body still carries a status a GET can fail over
+        // on. Other non-JSON statuses, including 404 and 500, keep the previous
+        // null response so they do not fail over.
         return {
             baseUrl,
             errors: [{ message: `${status}: ${message}`, type: status }],
             json: null,
-            response: null,
+            response: isGatewayStatus(response.status) ? response : null,
             zonosMode,
         };
     }
 };
 const handleRequestWithFallback = async ({ basePathType: _basePathType, options, path, }) => {
-    var _a, _b;
+    var _a, _b, _c;
     // use vercel API if the path is `/api/bigcommerce`
     const isBigcommerceEndpoint = path.startsWith('/api/bigcommerce');
     const basePathType = isBigcommerceEndpoint
         ? 'vercel'
         : _basePathType;
     const startTime = performance.now();
-    const _c = await handleRequest({
+    const _d = await handleRequest({
         basePathType,
         options,
         path,
-    }), { errors, response } = _c, rest = __rest(_c, ["errors", "response"]);
+    }), { errors, response } = _d, rest = __rest(_d, ["errors", "response"]);
     const endTime = performance.now();
     const duration = endTime - startTime;
     // Send the load time api log
@@ -358,10 +458,16 @@ const handleRequestWithFallback = async ({ basePathType: _basePathType, options,
         (message.includes('signal is aborted') ||
             message.includes('The operation was aborted') ||
             message.includes('Fetch is aborted')));
-    const isUnknownError = !!unknownError || (response === null || response === void 0 ? void 0 : response.status) === 404 || (response === null || response === void 0 ? void 0 : response.status) === 500;
-    const shouldCallFallback = 
-    // If next fallback is available, and the error is unknown (Failed to fetch) or 404 or 500 (server error)
-    nextFallbackApiType && isUnknownError;
+    const statusCode = response === null || response === void 0 ? void 0 : response.status;
+    const gateway = statusCode !== undefined && isGatewayStatus(statusCode);
+    // handleFetch sets method, and a missing method is a GET.
+    const isIdempotentGet = ((_a = options === null || options === void 0 ? void 0 : options.method) !== null && _a !== void 0 ? _a : 'GET').toUpperCase() === 'GET';
+    const failedWithoutGateway = !!unknownError || statusCode === 404 || statusCode === 500;
+    const isUnknownError = failedWithoutGateway || gateway;
+    // Replay 502, 503, and 504 only for GET. A gateway timeout on a POST can
+    // mean the first host is still finishing a payment or order write.
+    const shouldCallFallback = nextFallbackApiType &&
+        (failedWithoutGateway || (gateway && isIdempotentGet));
     // Should log the error if it's unknown error
     if (isUnknownError && !isAbortError) {
         void sendErrorLog({
@@ -371,7 +477,7 @@ const handleRequestWithFallback = async ({ basePathType: _basePathType, options,
                 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()),
+                requestPayload: jsonParse((_b = options === null || options === void 0 ? void 0 : options.body) === null || _b === void 0 ? void 0 : _b.toString()) || ((_c = options === null || options === void 0 ? void 0 : options.body) === null || _c === void 0 ? void 0 : _c.toString()),
                 shouldCallFallback,
                 status: response === null || response === void 0 ? void 0 : response.status,
                 statusText: response === null || response === void 0 ? void 0 : response.statusText,
@@ -415,4 +521,4 @@ const handleFetch = async (path, _opts) => {
     });
 };
 
-export { getIsStagingMode as a, getAdditionalLogMetadata as b, fallbackApiList as f, getIsTestMode as g, handleFetch as h, isCheckoutMobile as i, jsonParse as j, logError as l, sendErrorLog as s };
+export { getIsStagingMode as a, safeRemoveItem as b, safeGetItem as c, getAdditionalLogMetadata as d, safeSetItem as e, fallbackApiList as f, getIsTestMode as g, handleFetch as h, isCheckoutMobile as i, jsonParse as j, logError as l, sendErrorLog as s, thrownMessage as t };

package/dist/esm/{hasInclusivePrice-CbEfIhI5.js → hasInclusivePrice-zSvDReDb.js}

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

package/dist/esm/index.js

@@ -1,12 +1,104 @@
+export { c as curpRegex, i as isMexicoTaxIdType, a as isPeruTaxIdType, p as peruTaxIdTypeFromValue, s as stripTaxIdSeparators } from './taxIdRules-xYlx7ZXW.js';
 import { c as createCustomEvent } from './createCustomEvent-XQfWgQLB.js';
 import { g as getGenericSettingsOverride, I as IframeService } from './getGenericSettingsOverride-HeAZDwVW.js';
+import { t as thrownMessage, s as sendErrorLog, g as getIsTestMode, a as getIsStagingMode, h as handleFetch, l as logError, b as safeRemoveItem, c as safeGetItem } from './handleFetch-BFVO7oAR.js';
 import { l as log } from './VarianceTest-BJmZPrZl.js';
 export { a as availableTestKeys } from './VarianceTest-BJmZPrZl.js';
-import { g as getIsTestMode, a as getIsStagingMode, h as handleFetch, l as logError } from './handleFetch-D5GYDF-O.js';
 import { g as getAbandonedCartRenewTokenValue, _ as _getIsValidCartId, c as checkoutHiddenBtnSelector, a as checkoutHiddenInternationalBtnSelector } from './CheckoutConfig-D5SpFsQJ.js';
 export { d as domesticRedirectedBtnSelector } from './CheckoutConfig-D5SpFsQJ.js';
 export { c as countryRequireShortAddressCode } from './ShortAddressCode-nJ6oI8-n.js';
-export { c as countryRequireTaxId, e as euCountryCodes, s as shipToTaxIdLabels } from './TaxId-Cye-evFK.js';
+export { a as checkoutTaxIdTypeValues, c as countryRequireTaxId, e as euCountryCodes, i as isCountryRequireTaxId, p as peruTaxIdDigitLength, b as peruTaxIdFormatError, s as shipToTaxIdLabels, t as taxIdTypeOptions } from './TaxId-DMIgN_sT.js';
+
+const constructorNotFound = /^Constructor for .+ was not found/;
+const constructorTag = /^Constructor for "?([^#"]+)#/;
+const recordConstructorFailure = (value) => {
+    var _a;
+    const message = thrownMessage(value, '');
+    if (!message || !constructorNotFound.test(message)) {
+        return;
+    }
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    const capture = window.__zonosConstructorCapture;
+    if (!capture) {
+        return;
+    }
+    const tagMatch = constructorTag.exec(message);
+    const tag = (_a = tagMatch === null || tagMatch === void 0 ? void 0 : tagMatch[1]) !== null && _a !== void 0 ? _a : '';
+    if (capture.reported.has(tag)) {
+        return;
+    }
+    capture.reported.add(tag);
+    void sendErrorLog({
+        endpoint: 'stencil://constructor',
+        errors: [message],
+        metadata: {
+            shape: 'constructor-not-found',
+            tag,
+        },
+    });
+};
+/**
+ * Copy a missing-constructor failure onto the existing error log.
+ * Stencil catches `Constructor for "tag#mode" was not found` and passes that
+ * Error to `console.error`. One report is sent per tag, then the original
+ * console.error still runs. This does not request the chunk again.
+ */
+const installConstructorCapture = () => {
+    if (window.__zonosConstructorCapture) {
+        return;
+    }
+    const listener = (event) => {
+        recordConstructorFailure(event.reason);
+    };
+    window.__zonosConstructorCapture = {
+        listener,
+        reported: new Set(),
+    };
+    window.addEventListener('unhandledrejection', listener);
+    // eslint-disable-next-line no-console -- Stencil reports the missing constructor here
+    const originalError = console.error.bind(console);
+    // eslint-disable-next-line no-console -- record the Stencil diagnostic, then forward it
+    console.error = (...data) => {
+        recordConstructorFailure(data[0]);
+        originalError(...data);
+    };
+};
+
+const reportInitRejection = (error) => {
+    // sendErrorLog prints only when zonosDebug is on. Keep the failure in the
+    // merchant console without leaving an unhandled rejection.
+    // eslint-disable-next-line no-console -- the page console is the support signal
+    console.error(error);
+    if (typeof window.Zonos === 'undefined') {
+        return;
+    }
+    void sendErrorLog({
+        endpoint: 'zonos://init',
+        errors: [thrownMessage(error, 'Unknown init rejection')],
+        metadata: {
+            shape: 'init-rejection',
+        },
+    });
+};
+/**
+ * Run an init that the caller is not waiting on. The rejection is recorded
+ * and not rethrown, so startup does not become an unhandled rejection.
+ */
+const startZonosInit = (start) => {
+    let pending;
+    try {
+        pending = start();
+    }
+    catch (error) {
+        reportInitRejection(error);
+        return;
+    }
+    void pending.catch((error) => {
+        reportInitRejection(error);
+    });
+};
 
 /**
  * Get the load version and url based on the loadScriptSrc and version
@@ -131,7 +223,7 @@ const getZonosQaUrl = () => {
         return null;
     }
     const qaUrl = extractZonosQaUrl(window.location.href);
-    const cdnUrl = "https://v1.5.0.js.zonos.com";
+    const cdnUrl = "https://v1.5.2.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.') ||
@@ -166,8 +258,8 @@ const getZonosQaUrl = () => {
     void fetch(fullUrl)
         .then(() => {
         // cleanup checkout session to avoid using the prod session in preview domain
-        window.sessionStorage.removeItem('zonos--checkout-session-id');
-        window.sessionStorage.removeItem('zonos--client-secret');
+        safeRemoveItem('session', 'zonos--checkout-session-id');
+        safeRemoveItem('session', 'zonos--client-secret');
     })
         .catch(() => {
         alert(`[ZONOS-WARNING] '${fullUrl}' IS NO LONGER AVAILABLE. REMOVING zonosQaUrl PARAM AND RELOADING THE PAGE`);
@@ -420,10 +512,10 @@ const zonosLoadUrl = (() => {
     return null;
 })();
 const startLoadTime = Date.now();
-const ZONOS_URL = "https://v1.5.0.js.zonos.com";
-const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.5.0";
-const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.5.0";
-const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.5.0";
+const ZONOS_URL = "https://v1.5.2.js.zonos.com";
+const JS_DELIVR_ZONOS_URL = zonosLoadUrl || "https://cdn.jsdelivr.net/npm/@zonos/elements@1.5.2";
+const UNPKG_ZONOS_URL = "https://unpkg.com/@zonos/elements@1.5.2";
+const CDNJS_ZONOS_URL = "https://cdnjs.cloudflare.com/ajax/libs/zonos-elements/1.5.2";
 const GOOGLE_FONT_URL = 'https://fonts.googleapis.com';
 const GOOGLE_FONT_REGEX = /^https:\/\/fonts\.googleapis\.com/;
 class Zonos {
@@ -441,7 +533,7 @@ Zonos.iframeLogType = typeof window !== 'undefined'
     ? new URLSearchParams(window.location.search).get('iframeLogType')
     : null;
 Zonos.isBigCommerce = false;
-Zonos.releaseDate = "1792773585238";
+Zonos.releaseDate = "1793899893283";
 Zonos.isLegacyCheckout = false;
 Zonos.googleAnalyticId = null;
 Zonos.googleAnalyticReady = false;
@@ -466,7 +558,7 @@ Zonos.isNpm = true;
 Zonos.zonosQaUrl = null;
 Zonos.zonosQaUrlApi = null;
 Zonos.trackEventLogs = [];
-Zonos.version = `v${"1.5.0"}`;
+Zonos.version = `v${"1.5.2"}`;
 Zonos.modeAlerted = false;
 Zonos.cartData = null;
 Zonos.paypal = null;
@@ -477,6 +569,7 @@ Zonos.zonosController = null;
 Zonos.loadTimeApiInfoList = [];
 Zonos.logIntervalId = null;
 Zonos.init = async (params) => {
+    installConstructorCapture();
     const { appearance, checkoutSettings, currencyConverter, helloSettings, onCountryChange, overrideCurrencyFormat, storeId, zonosApiKey, } = params;
     _a.cartId = getCartIdFromQueryParam();
     // Expose the checkout cart callbacks on the global so Stripe loading can be
@@ -512,7 +605,7 @@ Zonos.init = async (params) => {
                 window.Zonos.isLegacyCheckout = _a.isLegacyCheckout;
                 window.Zonos.zonosMode = _a.zonosMode;
                 // call init again after the script is loaded
-                void window.Zonos.init(params);
+                startZonosInit(() => window.Zonos.init(params));
             });
             script.addEventListener('error', () => {
                 alert(`[ZONOS - loadZonos] Failed to load "loadZonos.js" from zonosQaUrl: ${zonosQaUrl}`);
@@ -548,7 +641,7 @@ Zonos.init = async (params) => {
         }
     }
     // Check if the stripe client secret is available in the url or session storage, inject hidden button to trigger checkout right away to check status of client secret
-    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || sessionStorage.getItem('zonos--client-secret');
+    const clientSecretUrlParam = new URL(window.location.href).searchParams.get('payment_intent_client_secret') || safeGetItem('session', 'zonos--client-secret');
     const shouldAttemptImmediatelyOpenCheckout = (_a.cartId && _a.cartData) || !!clientSecretUrlParam;
     // inject hidden button to body to trigger checkout right away if we have cartData or stripe client secret
     if (shouldAttemptImmediatelyOpenCheckout) {

package/dist/esm/{invoice-S1KahJ_Z.js → invoice-6iTuS6ek.js}

@@ -1,7 +1,7 @@
-import { c as createStore, z as zonosStore } from './zonosStore-msUlqmSD.js';
-import { d as cartStore, Y as cartStoreUpdateSelectedShippingOption, b as stripeStore, a0 as stripeStoreBuildAddressForPartyCreate } from './cart-BoQp8Ema.js';
-import { s as storageStore } from './localization-BIh-4pc_.js';
-import { h as handleFetch, s as sendErrorLog, l as logError } from './handleFetch-D5GYDF-O.js';
+import { c as createStore, z as zonosStore } from './zonosStore-BXP9FvIt.js';
+import { d as cartStore, Z as cartStoreUpdateSelectedShippingOption, b as stripeStore, a1 as stripeStoreBuildAddressForPartyCreate } from './cart-BS5mSI8x.js';
+import { s as storageStore } from './localization-CXHiWcJp.js';
+import { h as handleFetch, s as sendErrorLog, l as logError } from './handleFetch-BFVO7oAR.js';
 import { b as allLogs } from './VarianceTest-BJmZPrZl.js';
 
 const { state: invoiceStore } = createStore(() => ({