@tagadapay/plugin-sdk 3.1.11 → 3.1.22

package/dist/tagada-sdk.js

@@ -1,17 +1,19 @@
 /**
- * TagadaPay SDK v3.1.11
+ * TagadaPay SDK v3.1.22
  * CDN Bundle - Full standalone SDK (Debug Build)
  * Usage: window.tgd.createTagadaClient(), window.tgd.formatMoney(), etc.
  * @license MIT
  */
 "use strict";
 var TagadaSDKBundle = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __defProps = Object.defineProperties;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
   var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
@@ -34,6 +36,9 @@ var TagadaSDKBundle = (() => {
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all3) => {
     for (var name in all3)
       __defProp(target, name, { get: all3[name], enumerable: true });
@@ -46,6 +51,14 @@ var TagadaSDKBundle = (() => {
     }
     return to;
   };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
   var __await = function(promise, isYieldStar) {
     this[0] = promise;
@@ -1173,7 +1186,7 @@ var TagadaSDKBundle = (() => {
         TrackingProvider2["FACEBOOK"] = "facebook";
         TrackingProvider2["TIKTOK"] = "tiktok";
         TrackingProvider2["SNAPCHAT"] = "snapchat";
-        TrackingProvider2["META_CONVERSION"] = "meta_conversion";
+        TrackingProvider2["PINTEREST"] = "pinterest";
         TrackingProvider2["GTM"] = "gtm";
         return TrackingProvider2;
       })(TrackingProvider || {});
@@ -1582,6 +1595,361 @@ var TagadaSDKBundle = (() => {
     }
   });
 
+  // ../../node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js
+  var require_dist = __commonJS({
+    "../../node_modules/.pnpm/path-to-regexp@8.3.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.PathError = exports.TokenData = void 0;
+      exports.parse = parse;
+      exports.compile = compile;
+      exports.match = match2;
+      exports.pathToRegexp = pathToRegexp;
+      exports.stringify = stringify;
+      var DEFAULT_DELIMITER = "/";
+      var NOOP_VALUE = (value) => value;
+      var ID_START = new RegExp("^[$_\\p{ID_Start}]$", "u");
+      var ID_CONTINUE = new RegExp("^[$\\u200c\\u200d\\p{ID_Continue}]$", "u");
+      var SIMPLE_TOKENS = {
+        // Groups.
+        "{": "{",
+        "}": "}",
+        // Reserved.
+        "(": "(",
+        ")": ")",
+        "[": "[",
+        "]": "]",
+        "+": "+",
+        "?": "?",
+        "!": "!"
+      };
+      function escapeText(str) {
+        return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
+      }
+      function escape(str) {
+        return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+      }
+      var TokenData = class {
+        constructor(tokens, originalPath) {
+          this.tokens = tokens;
+          this.originalPath = originalPath;
+        }
+      };
+      exports.TokenData = TokenData;
+      var PathError = class extends TypeError {
+        constructor(message, originalPath) {
+          let text = message;
+          if (originalPath)
+            text += ": ".concat(originalPath);
+          text += "; visit https://git.new/pathToRegexpError for info";
+          super(text);
+          this.originalPath = originalPath;
+        }
+      };
+      exports.PathError = PathError;
+      function parse(str, options = {}) {
+        const { encodePath = NOOP_VALUE } = options;
+        const chars = [...str];
+        const tokens = [];
+        let index = 0;
+        let pos = 0;
+        function name() {
+          let value = "";
+          if (ID_START.test(chars[index])) {
+            do {
+              value += chars[index++];
+            } while (ID_CONTINUE.test(chars[index]));
+          } else if (chars[index] === '"') {
+            let quoteStart = index;
+            while (index++ < chars.length) {
+              if (chars[index] === '"') {
+                index++;
+                quoteStart = 0;
+                break;
+              }
+              if (chars[index] === "\\")
+                index++;
+              value += chars[index];
+            }
+            if (quoteStart) {
+              throw new PathError("Unterminated quote at index ".concat(quoteStart), str);
+            }
+          }
+          if (!value) {
+            throw new PathError("Missing parameter name at index ".concat(index), str);
+          }
+          return value;
+        }
+        while (index < chars.length) {
+          const value = chars[index];
+          const type = SIMPLE_TOKENS[value];
+          if (type) {
+            tokens.push({ type, index: index++, value });
+          } else if (value === "\\") {
+            tokens.push({ type: "escape", index: index++, value: chars[index++] });
+          } else if (value === ":") {
+            tokens.push({ type: "param", index: index++, value: name() });
+          } else if (value === "*") {
+            tokens.push({ type: "wildcard", index: index++, value: name() });
+          } else {
+            tokens.push({ type: "char", index: index++, value });
+          }
+        }
+        tokens.push({ type: "end", index, value: "" });
+        function consumeUntil(endType) {
+          const output = [];
+          while (true) {
+            const token = tokens[pos++];
+            if (token.type === endType)
+              break;
+            if (token.type === "char" || token.type === "escape") {
+              let path = token.value;
+              let cur = tokens[pos];
+              while (cur.type === "char" || cur.type === "escape") {
+                path += cur.value;
+                cur = tokens[++pos];
+              }
+              output.push({
+                type: "text",
+                value: encodePath(path)
+              });
+              continue;
+            }
+            if (token.type === "param" || token.type === "wildcard") {
+              output.push({
+                type: token.type,
+                name: token.value
+              });
+              continue;
+            }
+            if (token.type === "{") {
+              output.push({
+                type: "group",
+                tokens: consumeUntil("}")
+              });
+              continue;
+            }
+            throw new PathError("Unexpected ".concat(token.type, " at index ").concat(token.index, ", expected ").concat(endType), str);
+          }
+          return output;
+        }
+        return new TokenData(consumeUntil("end"), str);
+      }
+      function compile(path, options = {}) {
+        const { encode: encode3 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+        const data = typeof path === "object" ? path : parse(path, options);
+        const fn = tokensToFunction(data.tokens, delimiter, encode3);
+        return function path2(params = {}) {
+          const [path3, ...missing] = fn(params);
+          if (missing.length) {
+            throw new TypeError("Missing parameters: ".concat(missing.join(", ")));
+          }
+          return path3;
+        };
+      }
+      function tokensToFunction(tokens, delimiter, encode3) {
+        const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode3));
+        return (data) => {
+          const result = [""];
+          for (const encoder of encoders) {
+            const [value, ...extras] = encoder(data);
+            result[0] += value;
+            result.push(...extras);
+          }
+          return result;
+        };
+      }
+      function tokenToFunction(token, delimiter, encode3) {
+        if (token.type === "text")
+          return () => [token.value];
+        if (token.type === "group") {
+          const fn = tokensToFunction(token.tokens, delimiter, encode3);
+          return (data) => {
+            const [value, ...missing] = fn(data);
+            if (!missing.length)
+              return [value];
+            return [""];
+          };
+        }
+        const encodeValue = encode3 || NOOP_VALUE;
+        if (token.type === "wildcard" && encode3 !== false) {
+          return (data) => {
+            const value = data[token.name];
+            if (value == null)
+              return ["", token.name];
+            if (!Array.isArray(value) || value.length === 0) {
+              throw new TypeError('Expected "'.concat(token.name, '" to be a non-empty array'));
+            }
+            return [
+              value.map((value2, index) => {
+                if (typeof value2 !== "string") {
+                  throw new TypeError('Expected "'.concat(token.name, "/").concat(index, '" to be a string'));
+                }
+                return encodeValue(value2);
+              }).join(delimiter)
+            ];
+          };
+        }
+        return (data) => {
+          const value = data[token.name];
+          if (value == null)
+            return ["", token.name];
+          if (typeof value !== "string") {
+            throw new TypeError('Expected "'.concat(token.name, '" to be a string'));
+          }
+          return [encodeValue(value)];
+        };
+      }
+      function match2(path, options = {}) {
+        const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+        const { regexp, keys } = pathToRegexp(path, options);
+        const decoders = keys.map((key) => {
+          if (decode === false)
+            return NOOP_VALUE;
+          if (key.type === "param")
+            return decode;
+          return (value) => value.split(delimiter).map(decode);
+        });
+        return function match3(input) {
+          const m = regexp.exec(input);
+          if (!m)
+            return false;
+          const path2 = m[0];
+          const params = /* @__PURE__ */ Object.create(null);
+          for (let i = 1; i < m.length; i++) {
+            if (m[i] === void 0)
+              continue;
+            const key = keys[i - 1];
+            const decoder = decoders[i - 1];
+            params[key.name] = decoder(m[i]);
+          }
+          return { path: path2, params };
+        };
+      }
+      function pathToRegexp(path, options = {}) {
+        const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+        const keys = [];
+        const flags = sensitive ? "" : "i";
+        const sources = [];
+        for (const input of pathsToArray(path, [])) {
+          const data = typeof input === "object" ? input : parse(input, options);
+          for (const tokens of flatten(data.tokens, 0, [])) {
+            sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+          }
+        }
+        let pattern = "^(?:".concat(sources.join("|"), ")");
+        if (trailing)
+          pattern += "(?:".concat(escape(delimiter), "$)?");
+        pattern += end ? "$" : "(?=".concat(escape(delimiter), "|$)");
+        const regexp = new RegExp(pattern, flags);
+        return { regexp, keys };
+      }
+      function pathsToArray(paths, init) {
+        if (Array.isArray(paths)) {
+          for (const p of paths)
+            pathsToArray(p, init);
+        } else {
+          init.push(paths);
+        }
+        return init;
+      }
+      function* flatten(tokens, index, init) {
+        if (index === tokens.length) {
+          return yield init;
+        }
+        const token = tokens[index];
+        if (token.type === "group") {
+          for (const seq of flatten(token.tokens, 0, init.slice())) {
+            yield* __yieldStar(flatten(tokens, index + 1, seq));
+          }
+        } else {
+          init.push(token);
+        }
+        yield* __yieldStar(flatten(tokens, index + 1, init));
+      }
+      function toRegExpSource(tokens, delimiter, keys, originalPath) {
+        let result = "";
+        let backtrack = "";
+        let isSafeSegmentParam = true;
+        for (const token of tokens) {
+          if (token.type === "text") {
+            result += escape(token.value);
+            backtrack += token.value;
+            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+            continue;
+          }
+          if (token.type === "param" || token.type === "wildcard") {
+            if (!isSafeSegmentParam && !backtrack) {
+              throw new PathError('Missing text before "'.concat(token.name, '" ').concat(token.type), originalPath);
+            }
+            if (token.type === "param") {
+              result += "(".concat(negate(delimiter, isSafeSegmentParam ? "" : backtrack), "+)");
+            } else {
+              result += "([\\s\\S]+)";
+            }
+            keys.push(token);
+            backtrack = "";
+            isSafeSegmentParam = false;
+            continue;
+          }
+        }
+        return result;
+      }
+      function negate(delimiter, backtrack) {
+        if (backtrack.length < 2) {
+          if (delimiter.length < 2)
+            return "[^".concat(escape(delimiter + backtrack), "]");
+          return "(?:(?!".concat(escape(delimiter), ")[^").concat(escape(backtrack), "])");
+        }
+        if (delimiter.length < 2) {
+          return "(?:(?!".concat(escape(backtrack), ")[^").concat(escape(delimiter), "])");
+        }
+        return "(?:(?!".concat(escape(backtrack), "|").concat(escape(delimiter), ")[\\s\\S])");
+      }
+      function stringifyTokens(tokens) {
+        let value = "";
+        let i = 0;
+        function name(value2) {
+          const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
+          return isSafe ? value2 : JSON.stringify(value2);
+        }
+        while (i < tokens.length) {
+          const token = tokens[i++];
+          if (token.type === "text") {
+            value += escapeText(token.value);
+            continue;
+          }
+          if (token.type === "group") {
+            value += "{".concat(stringifyTokens(token.tokens), "}");
+            continue;
+          }
+          if (token.type === "param") {
+            value += ":".concat(name(token.name));
+            continue;
+          }
+          if (token.type === "wildcard") {
+            value += "*".concat(name(token.name));
+            continue;
+          }
+          throw new TypeError("Unknown token type: ".concat(token.type));
+        }
+        return value;
+      }
+      function stringify(data) {
+        return stringifyTokens(data.tokens);
+      }
+      function isNameSafe(name) {
+        const [first, ...rest] = name;
+        return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
+      }
+      function isNextNameSafe(token) {
+        if (token && token.type === "text")
+          return !ID_CONTINUE.test(token.value[0]);
+        return true;
+      }
+    }
+  });
+
   // src/v2/standalone/index.ts
   var index_exports = {};
   __export(index_exports, {
@@ -1590,15 +1958,28 @@ var TagadaSDKBundle = (() => {
     CheckoutUtils: () => CheckoutUtils,
     CurrencyUtils: () => CurrencyUtils,
     FunnelActionType: () => FunnelActionType,
+    GoogleAutocompleteCore: () => GoogleAutocompleteCore,
+    ISODataCore: () => ISODataCore,
     OrderBumpUtils: () => OrderBumpUtils,
     OrderUtils: () => OrderUtils,
+    OrdersResource: () => OrdersResource,
+    PaymentsResource: () => PaymentsResource,
     PluginConfigUtils: () => PluginConfigUtils,
     PostPurchasesUtils: () => PostPurchasesUtils,
     ProductsUtils: () => ProductsUtils,
     PromotionsUtils: () => PromotionsUtils,
+    ShippingRatesResource: () => ShippingRatesResource,
+    TagadaApiError: () => TagadaApiError,
+    TagadaAuthError: () => TagadaAuthError,
+    TagadaCircuitBreakerError: () => TagadaCircuitBreakerError,
     TagadaClient: () => TagadaClient,
+    TagadaError: () => TagadaError,
+    TagadaErrorCode: () => TagadaErrorCode,
     TagadaExternalTracker: () => TagadaExternalTracker,
+    TagadaNetworkError: () => TagadaNetworkError,
     TagadaTracker: () => TagadaTracker,
+    TagadaValidationError: () => TagadaValidationError,
+    applyGoogleAdsConversion: () => applyGoogleAdsConversion,
     broadcastConfigUpdate: () => broadcastConfigUpdate,
     clearFunnelSessionCookie: () => clearFunnelSessionCookie,
     createRawPluginConfig: () => createRawPluginConfig,
@@ -1606,13 +1987,26 @@ var TagadaSDKBundle = (() => {
     debounceConfigUpdate: () => debounceConfigUpdate,
     formatMoney: () => formatMoney,
     funnelQueryKeys: () => funnelQueryKeys,
+    getEligiblePixels: () => getEligiblePixels,
     getFunnelSessionCookie: () => getFunnelSessionCookie,
     getFunnelVariantId: () => getFunnelVariantId,
+    getInternalPath: () => getInternalPath,
+    getPathInfo: () => getPathInfo,
     getPluginConfig: () => getPluginConfig,
     hasFunnelSessionCookie: () => hasFunnelSessionCookie,
+    injectStepConfigScripts: () => injectStepConfigScripts,
+    isEventEnabled: () => isEventEnabled,
+    isPathRemapped: () => isPathRemapped,
     loadLocalConfig: () => loadLocalConfig,
     loadPluginConfig: () => loadPluginConfig,
+    mapGTMEvent: () => mapGTMEvent,
+    mapMetaEvent: () => mapMetaEvent,
+    mapPinterestEvent: () => mapPinterestEvent,
+    mapSnapchatEvent: () => mapSnapchatEvent,
+    mapTikTokEvent: () => mapTikTokEvent,
+    matchRoute: () => matchRoute,
     onConfigUpdate: () => onConfigUpdate,
+    resolvePixelEvents: () => resolvePixelEvents,
     sendConfigUpdate: () => sendConfigUpdate,
     setFunnelSessionCookie: () => setFunnelSessionCookie
   });
@@ -2221,8 +2615,8 @@ var TagadaSDKBundle = (() => {
       "%20": "+",
       "%00": "\0"
     };
-    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
-      return charMap[match];
+    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match2) {
+      return charMap[match2];
     });
   }
   function AxiosURLSearchParams(params, options) {
@@ -2401,8 +2795,8 @@ var TagadaSDKBundle = (() => {
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/formDataToJSON.js
   function parsePropPath(name) {
-    return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
-      return match[0] === "[]" ? "" : match[1] || match[0];
+    return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match2) => {
+      return match2[0] === "[]" ? "" : match2[1] || match2[0];
     });
   }
   function arrayToObject(arr) {
@@ -2620,9 +3014,9 @@ var TagadaSDKBundle = (() => {
   function parseTokens(str) {
     const tokens = /* @__PURE__ */ Object.create(null);
     const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-    let match;
-    while (match = tokensRE.exec(str)) {
-      tokens[match[1]] = match[2];
+    let match2;
+    while (match2 = tokensRE.exec(str)) {
+      tokens[match2[1]] = match2[2];
     }
     return tokens;
   }
@@ -2881,8 +3275,8 @@ var TagadaSDKBundle = (() => {
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/parseProtocol.js
   function parseProtocol(url) {
-    const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
-    return match && match[1] || "";
+    const match2 = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+    return match2 && match2[1] || "";
   }
 
   // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/speedometer.js
@@ -3026,8 +3420,8 @@ var TagadaSDKBundle = (() => {
       },
       read(name) {
         if (typeof document === "undefined") return null;
-        const match = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
-        return match ? decodeURIComponent(match[1]) : null;
+        const match2 = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
+        return match2 ? decodeURIComponent(match2[1]) : null;
       },
       remove(name) {
         this.write(name, "", Date.now() - 864e5, "/");
@@ -4238,6 +4632,86 @@ var TagadaSDKBundle = (() => {
     mergeConfig: mergeConfig2
   } = axios_default;
 
+  // src/v2/core/errors.ts
+  var TagadaErrorCode = {
+    NETWORK_ERROR: "network_error",
+    API_ERROR: "api_error",
+    AUTH_REQUIRED: "auth_required",
+    TOKEN_EXPIRED: "token_expired",
+    NOT_FOUND: "not_found",
+    VALIDATION_ERROR: "validation_error",
+    CIRCUIT_BREAKER: "circuit_breaker",
+    PAYMENT_FAILED: "payment_failed",
+    CARD_DECLINED: "card_declined",
+    SESSION_EXPIRED: "session_expired",
+    RATE_LIMITED: "rate_limited",
+    TIMEOUT: "timeout",
+    UNKNOWN: "unknown"
+  };
+  var TagadaError = class extends Error {
+    constructor(message, options) {
+      var _a;
+      super(message);
+      this.name = "TagadaError";
+      this.code = options.code;
+      this.statusCode = options.statusCode;
+      this.retryable = (_a = options.retryable) != null ? _a : false;
+      this.details = options.details;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+  var TagadaApiError = class extends TagadaError {
+    constructor(message, statusCode, options) {
+      var _a, _b;
+      super(message, {
+        code: (_a = options == null ? void 0 : options.code) != null ? _a : TagadaErrorCode.API_ERROR,
+        statusCode,
+        retryable: (_b = options == null ? void 0 : options.retryable) != null ? _b : statusCode >= 500,
+        details: options == null ? void 0 : options.details
+      });
+      this.name = "TagadaApiError";
+    }
+  };
+  var TagadaNetworkError = class extends TagadaError {
+    constructor(message = "Network request failed") {
+      super(message, {
+        code: TagadaErrorCode.NETWORK_ERROR,
+        retryable: true
+      });
+      this.name = "TagadaNetworkError";
+    }
+  };
+  var TagadaAuthError = class extends TagadaError {
+    constructor(message = "Authentication required", statusCode = 401) {
+      super(message, {
+        code: TagadaErrorCode.AUTH_REQUIRED,
+        statusCode,
+        retryable: false
+      });
+      this.name = "TagadaAuthError";
+    }
+  };
+  var TagadaValidationError = class extends TagadaError {
+    constructor(message, details) {
+      super(message, {
+        code: TagadaErrorCode.VALIDATION_ERROR,
+        statusCode: 400,
+        retryable: false,
+        details
+      });
+      this.name = "TagadaValidationError";
+    }
+  };
+  var TagadaCircuitBreakerError = class extends TagadaError {
+    constructor(message) {
+      super(message, {
+        code: TagadaErrorCode.CIRCUIT_BREAKER,
+        retryable: false
+      });
+      this.name = "TagadaCircuitBreakerError";
+    }
+  };
+
   // src/v2/core/resources/apiClient.ts
   var ApiClient = class {
     // Max 30 requests per endpoint in window
@@ -4295,12 +4769,18 @@ var TagadaSDKBundle = (() => {
         }
       );
       this.axios.interceptors.response.use(
-        (response) => {
-          return response;
-        },
+        (response) => response,
         (error) => {
           console.error("[SDK] Response error:", error.message);
-          return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+          if (error instanceof TagadaError) {
+            return Promise.reject(error);
+          }
+          if (axios_default.isAxiosError(error)) {
+            return Promise.reject(this.toTagadaError(error));
+          }
+          return Promise.reject(
+            error instanceof Error ? error : new Error(String(error))
+          );
         }
       );
     }
@@ -4366,30 +4846,66 @@ var TagadaSDKBundle = (() => {
     // Circuit Breaker Implementation
     checkRequestLimit(key) {
       const now = Date.now();
-      const history = this.requestHistory.get(key);
-      if (!history) {
+      const history2 = this.requestHistory.get(key);
+      if (!history2) {
         this.requestHistory.set(key, { count: 1, firstRequestTime: now });
         return;
       }
-      if (now - history.firstRequestTime > this.WINDOW_MS) {
+      if (now - history2.firstRequestTime > this.WINDOW_MS) {
         this.requestHistory.set(key, { count: 1, firstRequestTime: now });
         return;
       }
-      history.count++;
-      if (history.count > this.MAX_REQUESTS) {
-        const error = new Error("Circuit Breaker: Too many requests to ".concat(key, " (").concat(history.count, " in ").concat(this.WINDOW_MS, "ms)"));
-        error.isCircuitBreaker = true;
-        throw error;
+      history2.count++;
+      if (history2.count > this.MAX_REQUESTS) {
+        throw new TagadaCircuitBreakerError(
+          "Circuit Breaker: Too many requests to ".concat(key, " (").concat(history2.count, " in ").concat(this.WINDOW_MS, "ms)")
+        );
       }
     }
     cleanupHistory() {
       const now = Date.now();
-      for (const [key, history] of this.requestHistory.entries()) {
-        if (now - history.firstRequestTime > this.WINDOW_MS) {
+      for (const [key, history2] of this.requestHistory.entries()) {
+        if (now - history2.firstRequestTime > this.WINDOW_MS) {
           this.requestHistory.delete(key);
         }
       }
     }
+    /** Convert an AxiosError into the appropriate TagadaError subclass. */
+    toTagadaError(error) {
+      var _a, _b, _c, _d, _e;
+      const status = (_a = error.response) == null ? void 0 : _a.status;
+      const data = (_b = error.response) == null ? void 0 : _b.data;
+      const serverMessage = (_d = (_c = data == null ? void 0 : data.message) != null ? _c : data == null ? void 0 : data.error) != null ? _d : error.message;
+      if (!error.response) {
+        if (error.code === "ECONNABORTED") {
+          return new TagadaApiError("Request timed out", 0, {
+            code: TagadaErrorCode.TIMEOUT,
+            retryable: true
+          });
+        }
+        return new TagadaNetworkError(serverMessage);
+      }
+      if (status === 401 || status === 403) {
+        return new TagadaAuthError(serverMessage, status);
+      }
+      if (status === 429) {
+        return new TagadaApiError(serverMessage, 429, {
+          code: TagadaErrorCode.RATE_LIMITED,
+          retryable: true
+        });
+      }
+      if (status === 404) {
+        return new TagadaApiError(serverMessage, 404, {
+          code: TagadaErrorCode.NOT_FOUND,
+          retryable: false
+        });
+      }
+      return new TagadaApiError(serverMessage, status != null ? status : 0, {
+        code: (_e = data == null ? void 0 : data.code) != null ? _e : TagadaErrorCode.API_ERROR,
+        details: data,
+        retryable: (status != null ? status : 0) >= 500
+      });
+    }
   };
 
   // ../../node_modules/.pnpm/@ua-parser-js+pro-enterprise@2.0.6/node_modules/@ua-parser-js/pro-enterprise/src/main/ua-parser.mjs
@@ -4558,7 +5074,7 @@ var TagadaSDKBundle = (() => {
   };
   var rgxMapper = function(ua, arrays) {
     if (!ua || !arrays) return;
-    var i = 0, j, k, p, q, matches, match;
+    var i = 0, j, k, p, q, matches, match2;
     while (i < arrays.length && !matches) {
       var regex = arrays[i], props = arrays[i + 1];
       j = k = 0;
@@ -4569,34 +5085,34 @@ var TagadaSDKBundle = (() => {
         matches = regex[j++].exec(ua);
         if (!!matches) {
           for (p = 0; p < props.length; p++) {
-            match = matches[++k];
+            match2 = matches[++k];
             q = props[p];
             if (typeof q === TYPEOF.OBJECT && q.length > 0) {
               if (q.length === 2) {
                 if (typeof q[1] == TYPEOF.FUNCTION) {
-                  this[q[0]] = q[1].call(this, match);
+                  this[q[0]] = q[1].call(this, match2);
                 } else {
                   this[q[0]] = q[1];
                 }
               } else if (q.length >= 3) {
                 if (typeof q[1] === TYPEOF.FUNCTION && !(q[1].exec && q[1].test)) {
                   if (q.length > 3) {
-                    this[q[0]] = match ? q[1].apply(this, q.slice(2)) : void 0;
+                    this[q[0]] = match2 ? q[1].apply(this, q.slice(2)) : void 0;
                   } else {
-                    this[q[0]] = match ? q[1].call(this, match, q[2]) : void 0;
+                    this[q[0]] = match2 ? q[1].call(this, match2, q[2]) : void 0;
                   }
                 } else {
                   if (q.length == 3) {
-                    this[q[0]] = match ? match.replace(q[1], q[2]) : void 0;
+                    this[q[0]] = match2 ? match2.replace(q[1], q[2]) : void 0;
                   } else if (q.length == 4) {
-                    this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : void 0;
+                    this[q[0]] = match2 ? q[3].call(this, match2.replace(q[1], q[2])) : void 0;
                   } else if (q.length > 4) {
-                    this[q[0]] = match ? q[3].apply(this, [match.replace(q[1], q[2])].concat(q.slice(4))) : void 0;
+                    this[q[0]] = match2 ? q[3].apply(this, [match2.replace(q[1], q[2])].concat(q.slice(4))) : void 0;
                   }
                 }
               }
             } else {
-              this[q] = match ? match : void 0;
+              this[q] = match2 ? match2 : void 0;
             }
           }
         }
@@ -8750,7 +9266,7 @@ var TagadaSDKBundle = (() => {
       }
     }
     updateSessionState(response, sessionData) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       if (response.store) {
         const storeData = response.store;
         const storeConfig = __spreadProps(__spreadValues({}, response.store), {
@@ -8788,8 +9304,10 @@ var TagadaSDKBundle = (() => {
         customer: (_g = response.customer) != null ? _g : null,
         auth: authState
       });
-      if (this.funnel && sessionData.customerId && ((_h = response.store) == null ? void 0 : _h.id)) {
-        const accountId = response.store.accountId || ((_i = this.state.pluginConfig) == null ? void 0 : _i.accountId) || sessionData.accountId || "";
+      const funnelFeature = (_h = this.config.features) == null ? void 0 : _h.funnel;
+      const skipAutoInit = typeof funnelFeature === "object" && funnelFeature.skipAutoInit;
+      if (this.funnel && !skipAutoInit && sessionData.customerId && ((_i = response.store) == null ? void 0 : _i.id)) {
+        const accountId = response.store.accountId || ((_j = this.state.pluginConfig) == null ? void 0 : _j.accountId) || sessionData.accountId || "";
         if (accountId) {
           const urlParams = new URLSearchParams(typeof window !== "undefined" ? window.location.search : "");
           const funnelId = urlParams.get("funnelId") || void 0;
@@ -9249,6 +9767,14 @@ var TagadaSDKBundle = (() => {
     async getAppliedPromotions(checkoutSessionId) {
       return this.apiClient.get("/api/v1/checkout-sessions/".concat(checkoutSessionId, "/promotions"));
     }
+    /**
+     * Replace all session line items (full rewrite)
+     */
+    async replaceSessionLineItems(checkoutSessionId, lineItems) {
+      return this.apiClient.post("/api/v1/checkout-sessions/".concat(checkoutSessionId, "/line-items"), {
+        lineItems
+      });
+    }
     /**
      * Update line items
      */
@@ -9310,118 +9836,696 @@ var TagadaSDKBundle = (() => {
   };
 
   // src/v2/standalone/index.ts
-  init_funnel();
+  init_funnelClient();
 
-  // src/v2/core/utils/products.ts
-  var ProductsUtils = class {
+  // src/v2/core/resources/shippingRates.ts
+  var ShippingRatesResource = class {
+    constructor(apiClient) {
+      this.apiClient = apiClient;
+    }
     /**
-     * Find a variant by ID within products
+     * Get shipping rates for a checkout session
      */
-    static findVariant(products, variantId) {
-      for (const product of products) {
-        const variant = product.variants.find((v) => v.id === variantId);
-        if (variant) {
-          return variant;
-        }
-      }
-      return null;
+    async getShippingRates(sessionId) {
+      return this.apiClient.get("/api/v1/checkout-sessions/".concat(sessionId, "/shipping-rates"));
     }
     /**
-     * Get price for a variant in a specific currency
+     * Set selected shipping rate for a checkout session
      */
-    static getVariantPrice(variant, currency = "USD") {
-      const price = variant.prices.find((p) => p.currency === currency);
-      if (price) {
-        return price;
-      }
-      const defaultPrice = variant.prices.find((p) => p.default);
-      if (defaultPrice) {
-        return defaultPrice;
+    async setShippingRate(sessionId, shippingRateId) {
+      return this.apiClient.post("/api/v1/checkout-sessions/".concat(sessionId, "/shipping-rate"), {
+        shippingRateId
+      });
+    }
+    /**
+     * Preview shipping rates for a country without updating session
+     * Useful for showing rates before user enters email
+     */
+    async previewShippingRates(sessionId, params) {
+      const queryParams = new URLSearchParams({ countryCode: params.countryCode });
+      if (params.stateCode) {
+        queryParams.set("stateCode", params.stateCode);
       }
-      return variant.prices[0] || null;
+      return this.apiClient.get(
+        "/api/v1/checkout-sessions/".concat(sessionId, "/shipping-rates/preview?").concat(queryParams.toString())
+      );
+    }
+  };
+
+  // src/v2/core/resources/payments.ts
+  var PaymentsResource = class {
+    constructor(apiClient) {
+      this.apiClient = apiClient;
     }
     /**
-     * Get all variants from products
+     * Create payment instrument
      */
-    static getAllVariants(products) {
-      const allVariants = [];
-      for (const product of products) {
-        if (product.variants) {
-          for (const variant of product.variants) {
-            allVariants.push({ product, variant });
-          }
+    async createPaymentInstrument(paymentInstrumentData) {
+      return this.apiClient.post("/api/v1/payment/create-payment-instrument", {
+        paymentInstrumentData
+      });
+    }
+    /**
+     * Create card payment instrument
+     */
+    async createCardPaymentInstrument(basisTheory, cardData) {
+      var _a, _b;
+      if (!basisTheory) {
+        throw new Error("Payment processor not initialized");
+      }
+      console.log("Creating card payment instrument");
+      const btResponse = await basisTheory.tokens.create({
+        type: "card",
+        data: __spreadValues({
+          cvc: cardData.cvc,
+          number: Number(cardData.cardNumber.replace(/\s+/g, ""))
+        }, this.getCardMonthAndYear(cardData.expiryDate)),
+        metadata: {
+          nonSensitiveField: "nonSensitiveValue"
         }
-      }
-      return allVariants;
+      });
+      const { expiration_month, expiration_year } = this.getCardMonthAndYear(cardData.expiryDate);
+      const paymentInstrumentData = {
+        type: btResponse.type,
+        card: {
+          maskedCardNumber: ((_b = (_a = btResponse.enrichments) == null ? void 0 : _a.cardDetails) == null ? void 0 : _b.bin) ? "".concat(btResponse.enrichments.cardDetails.bin, "****").concat(btResponse.enrichments.cardDetails.last4) : cardData.cardNumber.replace(/\d(?=\d{4})/g, "*"),
+          expirationMonth: expiration_month,
+          expirationYear: expiration_year
+        },
+        token: btResponse.id
+      };
+      const response = await this.apiClient.post(
+        "/api/v1/payment/create-payment-instrument",
+        { paymentInstrumentData }
+      );
+      console.log("Payment instrument created:", response);
+      return response;
     }
     /**
-     * Filter variants by predicate
+     * Create Apple Pay payment instrument
      */
-    static filterVariants(products, predicate) {
-      const filtered = [];
-      for (const product of products) {
-        if (product.variants) {
-          for (const variant of product.variants) {
-            if (predicate(variant, product)) {
-              filtered.push({ product, variant });
-            }
-          }
+    async createApplePayPaymentInstrument(basisTheory, applePayToken) {
+      if (!basisTheory) {
+        throw new Error("Payment processor not initialized");
+      }
+      if (!applePayToken.id) {
+        throw new Error("Apple Pay token is missing");
+      }
+      const paymentInstrumentData = {
+        type: "apple_pay",
+        token: applePayToken.id,
+        dpanType: applePayToken.type,
+        card: {
+          bin: applePayToken.card.bin,
+          last4: applePayToken.card.last4,
+          expirationMonth: applePayToken.card.expiration_month,
+          expirationYear: applePayToken.card.expiration_year,
+          brand: applePayToken.card.brand
         }
+      };
+      const response = await this.apiClient.post(
+        "/api/v1/payment/create-payment-instrument",
+        { paymentInstrumentData }
+      );
+      return response;
+    }
+    /**
+     * Create Google Pay payment instrument
+     */
+    async createGooglePayPaymentInstrument(basisTheory, googlePayToken) {
+      var _a;
+      if (!basisTheory) {
+        throw new Error("Payment processor not initialized");
+      }
+      if (!googlePayToken.id) {
+        throw new Error("Google Pay token is missing");
+      }
+      const paymentInstrumentData = {
+        type: "google_pay",
+        token: googlePayToken.id,
+        dpanType: googlePayToken.type,
+        card: {
+          bin: googlePayToken.card.bin,
+          last4: googlePayToken.card.last4,
+          expirationMonth: googlePayToken.card.expiration_month,
+          expirationYear: googlePayToken.card.expiration_year,
+          brand: googlePayToken.card.brand
+        },
+        authMethod: (_a = googlePayToken == null ? void 0 : googlePayToken.details) == null ? void 0 : _a.auth_method
+      };
+      const response = await this.apiClient.post(
+        "/api/v1/payment/create-payment-instrument",
+        { paymentInstrumentData }
+      );
+      return response;
+    }
+    /**
+     * Create APM payment instrument (Klarna, Afterpay, PayPal, etc.)
+     */
+    async createApmPaymentInstrument(apmData) {
+      console.log("Creating APM payment instrument:", apmData);
+      const paymentInstrumentData = {
+        type: "apm",
+        provider: apmData.provider,
+        paymentMethod: apmData.paymentMethod,
+        processorId: apmData.processorId
+      };
+      const response = await this.apiClient.post(
+        "/api/v1/payment/create-payment-instrument",
+        { paymentInstrumentData }
+      );
+      console.log("APM payment instrument created:", response);
+      return response;
+    }
+    /**
+     * Helper function to format expiry date
+     */
+    getCardMonthAndYear(expiryDate) {
+      const [month, year] = expiryDate.split("/");
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+      const century = Math.floor(currentYear / 100) * 100;
+      const fullYear = Number(year) + century;
+      return {
+        expiration_month: Number(month),
+        expiration_year: fullYear
+      };
+    }
+    /**
+     * Process payment directly with checkout session
+     */
+    async processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) {
+      console.log("[PaymentsResource] processPaymentDirect START", options.paymentFlowId ? "(flow: ".concat(options.paymentFlowId, ")") : "");
+      console.log("[PaymentsResource] Full options object:", JSON.stringify(options, null, 2));
+      console.log("[PaymentsResource] processorId:", options.processorId, "paymentMethod:", options.paymentMethod);
+      try {
+        const requestBody = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+          checkoutSessionId,
+          paymentInstrumentId
+        }, threedsSessionId && { threedsSessionId }), options.initiatedBy && { initiatedBy: options.initiatedBy }), options.source && { source: options.source }), options.paymentFlowId && { paymentFlowId: options.paymentFlowId }), options.processorId && { processorId: options.processorId }), options.paymentMethod && { paymentMethod: options.paymentMethod });
+        console.log("[PaymentsResource] Request body being sent:", JSON.stringify(requestBody, null, 2));
+        const response = await this.apiClient.post("/api/public/v1/checkout/pay-v2", requestBody);
+        console.log("[PaymentsResource] processPaymentDirect SUCCESS:", response);
+        return response;
+      } catch (error) {
+        console.error("[PaymentsResource] processPaymentDirect ERROR:", error);
+        throw error;
       }
-      return filtered;
     }
-  };
-
-  // src/v2/core/utils/order.ts
-  var OrderUtils = class {
     /**
-     * Get order line items
+     * Get card payment instruments for customer
      */
-    static getOrderLineItems(order) {
-      return order.items || [];
+    async getCardPaymentInstruments() {
+      return this.apiClient.get("/api/v1/payment-instruments/customer");
     }
     /**
-     * Get order total
+     * Mark payment action as processed
      */
-    static getOrderTotal(order) {
-      return order.paidAmount || 0;
+    async markPaymentActionProcessed(paymentId) {
+      return this.apiClient.post("/api/v1/payments/require-action/processed", {
+        paymentId
+      });
     }
     /**
-     * Get order status
+     * Get payment status
      */
-    static getOrderStatus(order) {
-      return order.status || "unknown";
+    async getPaymentStatus(paymentId) {
+      return this.apiClient.get("/api/v1/payments/".concat(paymentId));
     }
     /**
-     * Check if order is completed
+     * Retrieve payment status from processor
+     * Used for external payment flows that require server-side status checks
      */
-    static isOrderCompleted(order) {
-      return order.status === "completed" || order.status === "fulfilled";
+    async retrievePayment(paymentId) {
+      return this.apiClient.post("/api/v1/payments/retrieve", {
+        paymentId
+      });
+    }
+    async saveRadarSession(data) {
+      return this.apiClient.post("/api/v1/radar-sessions", data);
     }
     /**
-     * Check if order is pending
+     * Complete payment after an action (3DS, radar, etc.)
+     * This resumes the payment flow that was paused for additional authentication/verification
      */
-    static isOrderPending(order) {
-      return order.status === "pending" || order.status === "processing";
+    async completePaymentAfterAction(paymentId) {
+      return this.apiClient.post("/api/v1/payments/complete-after-3ds", {
+        paymentId
+      });
     }
     /**
-     * Check if order is cancelled
+     * Update 3DS session status (used for Airwallex 3DS return handling)
      */
-    static isOrderCancelled(order) {
-      return order.status === "cancelled" || order.status === "refunded";
+    async updateThreedsStatus(data) {
+      return this.apiClient.post("/api/v1/threeds/status", data);
     }
   };
 
-  // src/v2/core/utils/currency.ts
-  function formatMoney(amountMinorUnits, currencyCode = "USD", locale = "en-US") {
-    const decimalPlaces = CurrencyUtils.getDecimalPlaces(currencyCode);
-    let value;
-    if (decimalPlaces === 0) {
-      value = amountMinorUnits / 100;
-    } else {
-      value = amountMinorUnits / Math.pow(10, decimalPlaces);
+  // src/v2/core/resources/orders.ts
+  var OrdersResource = class {
+    constructor(apiClient) {
+      this.apiClient = apiClient;
     }
-    try {
+    /**
+     * Fetch order by ID
+     */
+    async getOrder(orderId) {
+      const response = await this.apiClient.get("/api/v1/orders/".concat(orderId));
+      if (typeof response === "object" && response !== null && "success" in response && response.success === false) {
+        throw new Error(response.error || "Failed to fetch order");
+      }
+      const orderData = typeof response === "object" && response !== null && "order" in response ? response.order : response;
+      if (!orderData) {
+        throw new Error("Order not found");
+      }
+      return orderData;
+    }
+    /**
+     * Create a new order
+     */
+    async createOrder(checkoutSessionId) {
+      return this.apiClient.post("/api/v1/orders", {
+        checkoutSessionId
+      });
+    }
+    /**
+     * Update order status
+     */
+    async updateOrderStatus(orderId, status) {
+      return this.apiClient.patch("/api/v1/orders/".concat(orderId, "/status"), {
+        status
+      });
+    }
+    /**
+     * Add items to an order
+     */
+    async addOrderItems(orderId, items) {
+      return this.apiClient.post("/api/v1/orders/".concat(orderId, "/items"), {
+        items
+      });
+    }
+    /**
+     * Get order line items
+     */
+    async getOrderLineItems(orderId) {
+      const order = await this.getOrder(orderId);
+      return order.items || [];
+    }
+  };
+
+  // src/data/iso3166.ts
+  var GEODATA_CDN_BASE = "https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1";
+  var countriesCache = /* @__PURE__ */ new Map();
+  var regionsCache = /* @__PURE__ */ new Map();
+  var inflightCountries = /* @__PURE__ */ new Map();
+  var inflightRegions = /* @__PURE__ */ new Map();
+  async function fetchCountriesRaw(language) {
+    const cached = countriesCache.get(language);
+    if (cached) return cached;
+    let inflight = inflightCountries.get(language);
+    if (inflight) return inflight;
+    inflight = (async () => {
+      const url = "".concat(GEODATA_CDN_BASE, "/").concat(language, "/countries.json");
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("Geodata fetch failed: ".concat(url, " (").concat(res.status, ")"));
+      const data = await res.json();
+      countriesCache.set(language, data);
+      inflightCountries.delete(language);
+      return data;
+    })();
+    inflightCountries.set(language, inflight);
+    return inflight;
+  }
+  async function fetchRegionsRaw(language) {
+    const cached = regionsCache.get(language);
+    if (cached) return cached;
+    let inflight = inflightRegions.get(language);
+    if (inflight) return inflight;
+    inflight = (async () => {
+      const url = "".concat(GEODATA_CDN_BASE, "/").concat(language, "/regions.json");
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("Geodata fetch failed: ".concat(url, " (").concat(res.status, ")"));
+      const data = await res.json();
+      regionsCache.set(language, data);
+      inflightRegions.delete(language);
+      return data;
+    })();
+    inflightRegions.set(language, inflight);
+    return inflight;
+  }
+  function getCountriesCached(language) {
+    return countriesCache.get(language) || countriesCache.get("en") || {};
+  }
+  function getRegionsCached(language) {
+    return regionsCache.get(language) || regionsCache.get("en") || {};
+  }
+  async function ensureGeoDataLoaded(language = "en") {
+    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
+  }
+  var getCountries = (language = "en") => {
+    const raw = getCountriesCached(language);
+    return Object.entries(raw).map(([code, c]) => ({
+      code,
+      name: c.n,
+      iso3: c.i3,
+      numeric: c.nu,
+      uniqueKey: "country-".concat(code)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  var getStatesForCountry = (countryCode, language = "en") => {
+    const raw = getRegionsCached(language);
+    const tuples = raw[countryCode];
+    if (!tuples) return [];
+    return tuples.map(([iso, name], i) => ({
+      code: iso,
+      name,
+      countryCode,
+      uniqueKey: "state-".concat(countryCode, "-").concat(iso, "-").concat(i)
+    })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  function isLanguageRegistered(language) {
+    return countriesCache.has(language);
+  }
+  function getRegisteredLanguages() {
+    return [...countriesCache.keys()];
+  }
+  async function importLanguage(language) {
+    await ensureGeoDataLoaded(language);
+  }
+  if (typeof globalThis !== "undefined" && typeof fetch !== "undefined") {
+    ensureGeoDataLoaded("en").catch(() => {
+    });
+  }
+
+  // src/v2/core/isoData.ts
+  var ISODataCore = class {
+    /**
+     * Get countries data for a specific language
+     */
+    static getCountriesData(language = "en") {
+      try {
+        const countriesArray = getCountries(language);
+        const countries = {};
+        countriesArray.forEach((country) => {
+          countries[country.code] = {
+            iso: country.code,
+            iso3: country.iso3 || "",
+            numeric: country.numeric || 0,
+            name: country.name
+          };
+        });
+        return countries;
+      } catch (error) {
+        console.error("Failed to load ISO data for language: ".concat(language), error);
+        return {};
+      }
+    }
+    /**
+     * Get regions for a specific country
+     */
+    static getRegions(countryCode, language = "en") {
+      try {
+        const states = getStatesForCountry(countryCode, language);
+        return states.map((state) => ({
+          iso: state.code,
+          name: state.name
+        }));
+      } catch (e) {
+        return [];
+      }
+    }
+    /**
+     * Find a specific region by ISO code
+     */
+    static findRegion(countryCode, regionCode, language = "en") {
+      var _a;
+      const regions = this.getRegions(countryCode, language);
+      return (_a = regions.find((region) => region.iso === regionCode)) != null ? _a : null;
+    }
+    /**
+     * Map Google Places state to ISO region (proven 100% success rate)
+     */
+    static mapGoogleToISO(googleState, googleStateLong, countryCode, language = "en") {
+      const regions = this.getRegions(countryCode, language);
+      if (regions.length === 0) return null;
+      let match2 = regions.find((r) => r.iso === googleState);
+      if (match2) return match2;
+      match2 = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
+      if (match2) return match2;
+      match2 = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
+      if (match2) return match2;
+      match2 = regions.find(
+        (r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) || googleStateLong.toLowerCase().includes(r.name.toLowerCase())
+      );
+      return match2 != null ? match2 : null;
+    }
+    /**
+     * Check if language is registered
+     */
+    static isLanguageRegistered(language) {
+      return isLanguageRegistered(language);
+    }
+    /**
+     * Get registered languages
+     */
+    static getRegisteredLanguages() {
+      return getRegisteredLanguages();
+    }
+    /**
+     * Import language data
+     */
+    static async importLanguage(language) {
+      return importLanguage(language);
+    }
+    /**
+     * Get available languages for ISO data
+     */
+    static getAvailableLanguages() {
+      return ["en", "ru", "de", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
+    }
+  };
+
+  // src/v2/core/googleAutocomplete.ts
+  var GoogleAutocompleteCore = class {
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey) {
+      var _a, _b;
+      this.apiKey = apiKey;
+      if (typeof window !== "undefined" && ((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+        this.service = new window.google.maps.places.AutocompleteService();
+      }
+    }
+    /**
+     * Search for places
+     */
+    static async searchPlaces(input, options = {}) {
+      if (!this.service || !input.trim()) {
+        return [];
+      }
+      return new Promise((resolve, reject) => {
+        this.service.getPlacePredictions(
+          {
+            input,
+            types: options.types || ["address"],
+            componentRestrictions: options.componentRestrictions
+          },
+          (predictions, status) => {
+            var _a, _b, _c;
+            if (status === ((_c = (_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && predictions) {
+              resolve(predictions);
+            } else {
+              resolve([]);
+            }
+          }
+        );
+      });
+    }
+    /**
+     * Get place details
+     */
+    static async getPlaceDetails(placeId) {
+      var _a, _b;
+      if (typeof window === "undefined" || !((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+        return null;
+      }
+      return new Promise((resolve, reject) => {
+        const service = new window.google.maps.places.PlacesService(
+          document.createElement("div")
+        );
+        service.getDetails(
+          {
+            placeId,
+            fields: ["place_id", "formatted_address", "address_components", "geometry"]
+          },
+          (place, status) => {
+            var _a2, _b2, _c;
+            if (status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && place) {
+              resolve(place);
+            } else {
+              resolve(null);
+            }
+          }
+        );
+      });
+    }
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails) {
+      const components = {};
+      for (const component of placeDetails.address_components) {
+        const types = component.types;
+        if (types.includes("street_number")) {
+          components.streetNumber = component.long_name;
+        } else if (types.includes("route")) {
+          components.route = component.long_name;
+        } else if (types.includes("locality")) {
+          components.city = component.long_name;
+          components.locality = component.long_name;
+        } else if (types.includes("administrative_area_level_2")) {
+          components.administrativeAreaLevel2 = component.short_name;
+          components.administrativeAreaLevel2Long = component.long_name;
+          if (!components.city) {
+            components.city = component.long_name;
+            components.locality = component.long_name;
+          }
+        } else if (types.includes("administrative_area_level_1")) {
+          components.state = component.long_name;
+          components.administrativeAreaLevel1 = component.short_name;
+          components.administrativeAreaLevel1Long = component.long_name;
+        } else if (types.includes("postal_code")) {
+          components.postalCode = component.long_name;
+        } else if (types.includes("country")) {
+          components.country = component.long_name;
+          components.countryCode = component.short_name;
+          components.iso = component.short_name;
+        }
+      }
+      if (!components.administrativeAreaLevel1 && components.administrativeAreaLevel2) {
+        components.state = components.administrativeAreaLevel2Long || components.administrativeAreaLevel2;
+        components.administrativeAreaLevel1 = components.administrativeAreaLevel2;
+        components.administrativeAreaLevel1Long = components.administrativeAreaLevel2Long;
+      }
+      return components;
+    }
+  };
+  GoogleAutocompleteCore.apiKey = null;
+  GoogleAutocompleteCore.service = null;
+
+  // src/v2/standalone/index.ts
+  init_funnel();
+
+  // src/v2/core/utils/products.ts
+  var ProductsUtils = class {
+    /**
+     * Find a variant by ID within products
+     */
+    static findVariant(products, variantId) {
+      for (const product of products) {
+        const variant = product.variants.find((v) => v.id === variantId);
+        if (variant) {
+          return variant;
+        }
+      }
+      return null;
+    }
+    /**
+     * Get price for a variant in a specific currency
+     */
+    static getVariantPrice(variant, currency = "USD") {
+      const price = variant.prices.find((p) => p.currency === currency);
+      if (price) {
+        return price;
+      }
+      const defaultPrice = variant.prices.find((p) => p.default);
+      if (defaultPrice) {
+        return defaultPrice;
+      }
+      return variant.prices[0] || null;
+    }
+    /**
+     * Get all variants from products
+     */
+    static getAllVariants(products) {
+      const allVariants = [];
+      for (const product of products) {
+        if (product.variants) {
+          for (const variant of product.variants) {
+            allVariants.push({ product, variant });
+          }
+        }
+      }
+      return allVariants;
+    }
+    /**
+     * Filter variants by predicate
+     */
+    static filterVariants(products, predicate) {
+      const filtered = [];
+      for (const product of products) {
+        if (product.variants) {
+          for (const variant of product.variants) {
+            if (predicate(variant, product)) {
+              filtered.push({ product, variant });
+            }
+          }
+        }
+      }
+      return filtered;
+    }
+  };
+
+  // src/v2/core/utils/order.ts
+  var OrderUtils = class {
+    /**
+     * Get order line items
+     */
+    static getOrderLineItems(order) {
+      return order.items || [];
+    }
+    /**
+     * Get order total
+     */
+    static getOrderTotal(order) {
+      return order.paidAmount || 0;
+    }
+    /**
+     * Get order status
+     */
+    static getOrderStatus(order) {
+      return order.status || "unknown";
+    }
+    /**
+     * Check if order is completed
+     */
+    static isOrderCompleted(order) {
+      return order.status === "completed" || order.status === "fulfilled";
+    }
+    /**
+     * Check if order is pending
+     */
+    static isOrderPending(order) {
+      return order.status === "pending" || order.status === "processing";
+    }
+    /**
+     * Check if order is cancelled
+     */
+    static isOrderCancelled(order) {
+      return order.status === "cancelled" || order.status === "refunded";
+    }
+  };
+
+  // src/v2/core/utils/currency.ts
+  function formatMoney(amountMinorUnits, currencyCode = "USD", locale = "en-US") {
+    const decimalPlaces = CurrencyUtils.getDecimalPlaces(currencyCode);
+    let value;
+    if (decimalPlaces === 0) {
+      value = amountMinorUnits / 100;
+    } else {
+      value = amountMinorUnits / Math.pow(10, decimalPlaces);
+    }
+    try {
       return new Intl.NumberFormat(locale, {
         style: "currency",
         currency: currencyCode,
@@ -9710,18 +10814,23 @@ var TagadaSDKBundle = (() => {
       return ((_a = checkoutData.checkoutSession) == null ? void 0 : _a.id) || "";
     }
     /**
-     * Get checkout line items
+     * Get checkout line items  
      */
     static getLineItems(checkoutData) {
       var _a;
-      return ((_a = checkoutData.checkoutSession) == null ? void 0 : _a.lineItems) || [];
+      const lineItems = (_a = checkoutData.checkoutSession) == null ? void 0 : _a.lineItems;
+      if (!Array.isArray(lineItems)) {
+        return [];
+      }
+      return lineItems;
     }
     /**
      * Get checkout total
      */
     static getTotal(checkoutData) {
       var _a;
-      return ((_a = checkoutData.checkoutSession) == null ? void 0 : _a.totalPrice) || 0;
+      const totalPrice = (_a = checkoutData.checkoutSession) == null ? void 0 : _a.totalPrice;
+      return typeof totalPrice === "number" ? totalPrice : 0;
     }
     /**
      * Check if customer is club member
@@ -9912,8 +11021,597 @@ var TagadaSDKBundle = (() => {
     };
   }
 
+  // src/v2/core/pathRemapping.ts
+  var import_path_to_regexp = __toESM(require_dist());
+  var internalPathCache = void 0;
+  var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  var originalPushState = isBrowser ? history.pushState.bind(history) : null;
+  var originalReplaceState = isBrowser ? history.replaceState.bind(history) : null;
+  function clearCache() {
+    internalPathCache = void 0;
+  }
+  if (isBrowser) {
+    window.addEventListener("popstate", clearCache);
+    window.addEventListener("hashchange", clearCache);
+    history.pushState = function(...args) {
+      clearCache();
+      return originalPushState.apply(this, args);
+    };
+    history.replaceState = function(...args) {
+      clearCache();
+      return originalReplaceState.apply(this, args);
+    };
+  }
+  function getInternalPath() {
+    if (!isBrowser) {
+      if (typeof process !== "undefined" && true) {
+        console.warn("[TagadaPay SDK] getInternalPath() called in SSR context");
+      }
+      return null;
+    }
+    if (internalPathCache !== void 0) {
+      console.log("[TagadaPay SDK] \u{1F4E6} Returning cached internal path:", internalPathCache);
+      return internalPathCache;
+    }
+    console.log("[TagadaPay SDK] \u{1F50D} getInternalPath() called for:", window.location.pathname);
+    try {
+      const isLocalhost = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname.endsWith(".localhost");
+      console.log("[TagadaPay SDK] \u{1F3E0} isLocalhost:", isLocalhost);
+      if (isLocalhost) {
+        const urlParams = new URLSearchParams(window.location.search);
+        const queryRemap = urlParams.get("__remap");
+        console.log("[TagadaPay SDK] \u{1F50D} Query parameter __remap:", queryRemap);
+        if (queryRemap) {
+          internalPathCache = queryRemap;
+          if (typeof process !== "undefined" && true) {
+            console.log("[TagadaPay SDK] \u{1F527} Simulating path remap via query: ".concat(window.location.pathname, " \u2192 ").concat(queryRemap));
+          }
+          return queryRemap;
+        }
+        try {
+          const storageRemap = localStorage.getItem("tagadapay-remap");
+          console.log("[TagadaPay SDK] \u{1F50D} localStorage tagadapay-remap:", storageRemap);
+          if (storageRemap) {
+            try {
+              const remapConfig = JSON.parse(storageRemap);
+              console.log("[TagadaPay SDK] \u{1F4DD} Parsed remap config:", remapConfig);
+              if (remapConfig.externalPath && remapConfig.internalPath) {
+                const currentPath = window.location.pathname;
+                console.log("[TagadaPay SDK] \u{1F50D} Checking if", currentPath, "matches pattern", remapConfig.externalPath);
+                const matchFn = (0, import_path_to_regexp.match)(remapConfig.externalPath, {
+                  decode: decodeURIComponent,
+                  end: true
+                });
+                const result = matchFn(currentPath);
+                console.log("[TagadaPay SDK] \u{1F3AF} Match result:", result);
+                if (result !== false) {
+                  internalPathCache = remapConfig.internalPath;
+                  console.log("[TagadaPay SDK] \u2705 Path remap: ".concat(remapConfig.externalPath, " \u2192 ").concat(remapConfig.internalPath));
+                  console.log("[TagadaPay SDK] \u2705 Current URL ".concat(currentPath, " matches external pattern"));
+                  console.log("[TagadaPay SDK] \u{1F4E6} Caching and returning:", remapConfig.internalPath);
+                  return remapConfig.internalPath;
+                } else {
+                  console.log("[TagadaPay SDK] \u274C Current URL ".concat(currentPath, " does NOT match external pattern ").concat(remapConfig.externalPath));
+                  internalPathCache = null;
+                  return null;
+                }
+              } else {
+                console.log("[TagadaPay SDK] \u26A0\uFE0F Parsed config missing externalPath or internalPath");
+              }
+            } catch (jsonError) {
+              console.log("[TagadaPay SDK] \u26A0\uFE0F Failed to parse as JSON, using legacy format:", jsonError);
+              internalPathCache = storageRemap;
+              if (typeof process !== "undefined" && true) {
+                console.log("[TagadaPay SDK] \u{1F527} Simulating path remap (legacy): ".concat(window.location.pathname, " \u2192 ").concat(storageRemap));
+              }
+              return storageRemap;
+            }
+          } else {
+            console.log("[TagadaPay SDK] \u{1F4ED} No localStorage tagadapay-remap found");
+          }
+        } catch (e) {
+          console.log("[TagadaPay SDK] \u274C localStorage error:", e);
+        }
+      }
+      const fullRemapMetaTag = document.querySelector('meta[name="tagadapay-path-remap"]');
+      if (fullRemapMetaTag) {
+        try {
+          const content2 = fullRemapMetaTag.getAttribute("content");
+          if (content2) {
+            const decodedContent = decodeURIComponent(content2);
+            const parsed = JSON.parse(decodedContent);
+            if (parsed.internal) {
+              console.log("[TagadaPay SDK] \u2705 Got internal path from full remap config:", parsed.internal);
+              internalPathCache = parsed.internal;
+              return parsed.internal;
+            }
+          }
+        } catch (e) {
+          console.error("[TagadaPay SDK] Error parsing full remap config:", e);
+        }
+      }
+      const metaTag = document.querySelector('meta[name="x-plugin-internal-path"]');
+      if (!metaTag) {
+        console.log("[TagadaPay SDK] \u2139\uFE0F  No path remap meta tags found");
+        internalPathCache = null;
+        return null;
+      }
+      const content = metaTag.getAttribute("content");
+      if (!content || content.trim() === "") {
+        if (typeof process !== "undefined" && true) {
+          console.warn("[TagadaPay SDK] Meta tag found but content is empty");
+        }
+        internalPathCache = null;
+        return null;
+      }
+      const trimmedContent = content.trim();
+      if (!trimmedContent.startsWith("/")) {
+        if (typeof process !== "undefined" && true) {
+          console.warn('[TagadaPay SDK] Invalid internal path format: "'.concat(trimmedContent, '" (must start with /)'));
+        }
+        internalPathCache = null;
+        return null;
+      }
+      console.log("[TagadaPay SDK] \u2705 Got internal path from legacy meta tag:", trimmedContent);
+      internalPathCache = trimmedContent;
+      return trimmedContent;
+    } catch (error) {
+      if (typeof process !== "undefined" && true) {
+        console.error("[TagadaPay SDK] Error reading internal path:", error);
+      }
+      internalPathCache = null;
+      return null;
+    }
+  }
+  function isPathRemapped() {
+    return getInternalPath() !== null;
+  }
+  function getPathInfo() {
+    if (!isBrowser) {
+      throw new Error("[TagadaPay SDK] getPathInfo() cannot be called in SSR context");
+    }
+    try {
+      const externalPath = window.location.pathname;
+      const internalPath = getInternalPath();
+      const query = new URLSearchParams(window.location.search);
+      const hash = window.location.hash.replace(/^#/, "");
+      return {
+        externalPath,
+        internalPath,
+        isRemapped: internalPath !== null,
+        fullUrl: window.location.href,
+        query,
+        hash
+      };
+    } catch (error) {
+      if (typeof process !== "undefined" && true) {
+        console.error("[TagadaPay SDK] Error getting path info:", error);
+      }
+      return {
+        externalPath: "/",
+        internalPath: null,
+        isRemapped: false,
+        fullUrl: "",
+        query: new URLSearchParams(),
+        hash: ""
+      };
+    }
+  }
+  function matchesPathPattern(pathname, pattern) {
+    try {
+      if (pathname === pattern) {
+        return { matched: true, params: {} };
+      }
+      const hasPatternSyntax = pattern.includes(":") || pattern.includes("*") || pattern.includes("{");
+      if (!hasPatternSyntax) {
+        return { matched: pathname === pattern, params: {} };
+      }
+      const matchFn = (0, import_path_to_regexp.match)(pattern, {
+        decode: decodeURIComponent,
+        end: true
+      });
+      const result = matchFn(pathname);
+      if (typeof process !== "undefined" && true) {
+        console.log('[TagadaPay SDK] Pattern match: "'.concat(pathname, '" against "').concat(pattern, '" ='), result !== false);
+      }
+      if (result === false) {
+        return { matched: false, params: {} };
+      }
+      const params = {};
+      if (typeof result === "object" && result.params) {
+        Object.keys(result.params).forEach((key) => {
+          const value = result.params[key];
+          params[key] = Array.isArray(value) ? value.join("/") : String(value);
+        });
+      }
+      return { matched: true, params };
+    } catch (error) {
+      if (typeof process !== "undefined" && true) {
+        console.warn('[TagadaPay SDK] Pattern matching failed for "'.concat(pattern, '":'), error);
+      }
+      return { matched: pathname === pattern, params: {} };
+    }
+  }
+  function mapParamNames(externalParams, externalPattern, internalPattern) {
+    const externalParamNames = extractParamNames(externalPattern);
+    const internalParamNames = extractParamNames(internalPattern);
+    if (externalParamNames.length === 0 || externalParamNames.length !== internalParamNames.length) {
+      return externalParams;
+    }
+    const mappedParams = {};
+    externalParamNames.forEach((externalName, index) => {
+      const internalName = internalParamNames[index];
+      const value = externalParams[externalName];
+      if (value !== void 0) {
+        mappedParams[internalName] = value;
+      }
+    });
+    return mappedParams;
+  }
+  function extractParamNames(pattern) {
+    const matches = pattern.match(/:([a-zA-Z0-9_]+)/g);
+    if (!matches) return [];
+    return matches.map((m) => m.substring(1));
+  }
+  function matchRoute(internalPath) {
+    if (typeof internalPath !== "string") {
+      throw new Error("[TagadaPay SDK] internalPath must be a string, got ".concat(typeof internalPath));
+    }
+    if (internalPath.trim() === "") {
+      throw new Error("[TagadaPay SDK] internalPath cannot be empty");
+    }
+    if (!internalPath.startsWith("/")) {
+      throw new Error('[TagadaPay SDK] internalPath must start with /, got "'.concat(internalPath, '"'));
+    }
+    if (!isBrowser) {
+      return { matched: false, params: {} };
+    }
+    try {
+      const currentPath = window.location.pathname;
+      const remappedInternalPath = getInternalPath();
+      if (remappedInternalPath) {
+        const internalMatch = matchesPathPattern(remappedInternalPath, internalPath);
+        if (!internalMatch.matched) {
+          return { matched: false, params: {} };
+        }
+        let externalPattern = null;
+        if (typeof localStorage !== "undefined") {
+          try {
+            const remapData = localStorage.getItem("tagadapay-remap");
+            if (remapData) {
+              const parsed = JSON.parse(remapData);
+              if (parsed.externalPath && parsed.internalPath === remappedInternalPath) {
+                externalPattern = parsed.externalPath;
+              }
+            }
+          } catch (e) {
+          }
+        }
+        if (!externalPattern && typeof document !== "undefined") {
+          console.log("[TagadaPay SDK] \u{1F50D} Checking for production path remap meta tag...");
+          const metaTag = document.querySelector('meta[name="tagadapay-path-remap"]');
+          if (metaTag) {
+            try {
+              const content = metaTag.getAttribute("content");
+              console.log("[TagadaPay SDK] \u{1F4C4} Found meta tag content (encoded):", (content == null ? void 0 : content.substring(0, 100)) + "...");
+              if (content) {
+                const decodedContent = decodeURIComponent(content);
+                console.log("[TagadaPay SDK] \u{1F4C4} Decoded content:", decodedContent);
+                const parsed = JSON.parse(decodedContent);
+                console.log("[TagadaPay SDK] \u{1F4E6} Parsed remap config:", parsed);
+                console.log("[TagadaPay SDK] \u{1F50D} Checking if internal path matches:", {
+                  parsedInternal: parsed.internal,
+                  remappedInternalPath
+                });
+                if (parsed.external && parsed.internal === remappedInternalPath) {
+                  externalPattern = parsed.external;
+                  console.log("[TagadaPay SDK] \u2705 Using external pattern from meta tag:", externalPattern);
+                } else {
+                  console.log("[TagadaPay SDK] \u26A0\uFE0F  Internal path mismatch - not using meta tag config");
+                }
+              }
+            } catch (e) {
+              console.error("[TagadaPay SDK] \u274C Error parsing path remap meta tag:", e);
+            }
+          } else {
+            console.log("[TagadaPay SDK] \u274C No tagadapay-path-remap meta tag found");
+          }
+        }
+        if (externalPattern) {
+          const externalMatch = matchesPathPattern(currentPath, externalPattern);
+          if (externalMatch.matched) {
+            console.log("[TagadaPay SDK] \u{1F504} Mapping params from external to internal pattern");
+            console.log("[TagadaPay SDK]    External params:", externalMatch.params);
+            console.log("[TagadaPay SDK]    External pattern:", externalPattern);
+            console.log("[TagadaPay SDK]    Internal pattern:", internalPath);
+            const mappedParams = mapParamNames(
+              externalMatch.params,
+              externalPattern,
+              internalPath
+            );
+            console.log("[TagadaPay SDK]    Mapped params:", mappedParams);
+            return { matched: true, params: mappedParams };
+          }
+        }
+        const currentMatch = matchesPathPattern(currentPath, internalPath);
+        return { matched: true, params: currentMatch.params };
+      }
+      return matchesPathPattern(currentPath, internalPath);
+    } catch (error) {
+      if (typeof process !== "undefined" && true) {
+        console.error("[TagadaPay SDK] Error in matchRoute:", error);
+      }
+      return { matched: false, params: {} };
+    }
+  }
+
+  // src/v2/core/pixelMapping.ts
+  var ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+    "BIF",
+    "CLP",
+    "DJF",
+    "GNF",
+    "ISK",
+    "JPY",
+    "KMF",
+    "KRW",
+    "PYG",
+    "RWF",
+    "UGX",
+    "VND",
+    "VUV",
+    "XAF",
+    "XOF",
+    "XPF"
+  ]);
+  var THREE_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set(["BHD", "IQD", "JOD", "KWD", "LYD", "OMR", "TND"]);
+  function minorToMajor(amount, currency) {
+    const code = currency.toUpperCase();
+    if (ZERO_DECIMAL_CURRENCIES.has(code)) return amount;
+    if (THREE_DECIMAL_CURRENCIES.has(code)) return amount / 1e3;
+    return amount / 100;
+  }
+  function isEventEnabled(pixel, eventName) {
+    if (!("events" in pixel) || !pixel.events) return true;
+    const events = pixel.events;
+    if (!(eventName in events)) return true;
+    return events[eventName] === true;
+  }
+  function getEligiblePixels(pixels, eventName) {
+    if (!pixels) return [];
+    return pixels.filter((p) => p.enabled && isEventEnabled(p, eventName));
+  }
+  function ensureCurrencyUppercase(params) {
+    if (params.currency && typeof params.currency === "string") {
+      return __spreadProps(__spreadValues({}, params), { currency: params.currency.toUpperCase() });
+    }
+    return __spreadValues({}, params);
+  }
+  function convertValueToMajor(params) {
+    if (params.currency && params.value != null) {
+      const currency = String(params.currency);
+      const major = minorToMajor(Number(params.value), currency);
+      return __spreadProps(__spreadValues({}, params), { value: major });
+    }
+    return params;
+  }
+  function baseTransform(params) {
+    let p = ensureCurrencyUppercase(params);
+    p = convertValueToMajor(p);
+    return p;
+  }
+  var META_EVENT_MAP = {
+    PageView: "PageView",
+    ViewContent: "ViewContent",
+    AddToCart: "AddToCart",
+    AddToWishlist: "AddToWishlist",
+    Search: "Search",
+    InitiateCheckout: "InitiateCheckout",
+    AddPaymentInfo: "AddPaymentInfo",
+    Purchase: "Purchase",
+    Lead: "Lead",
+    CompleteRegistration: "CompleteRegistration"
+  };
+  function mapMetaEvent(eventName, parameters) {
+    var _a, _b;
+    const name = (_a = META_EVENT_MAP[eventName]) != null ? _a : eventName;
+    const params = baseTransform(parameters);
+    if (params.contents && Array.isArray(params.contents)) {
+      params.content_ids = params.contents.map((i) => i.content_id).filter(Boolean);
+      params.content_type = (_b = params.content_type) != null ? _b : "product";
+    }
+    return { name, params };
+  }
+  var TIKTOK_EVENT_MAP = {
+    PageView: "Pageview",
+    ViewContent: "ViewContent",
+    AddToCart: "AddToCart",
+    AddToWishlist: "AddToWishlist",
+    Search: "Search",
+    InitiateCheckout: "InitiateCheckout",
+    AddPaymentInfo: "AddPaymentInfo",
+    Purchase: "Purchase",
+    Lead: "SubmitForm",
+    CompleteRegistration: "CompleteRegistration"
+  };
+  function mapTikTokEvent(eventName, parameters) {
+    var _a, _b;
+    const name = (_a = TIKTOK_EVENT_MAP[eventName]) != null ? _a : eventName;
+    const params = baseTransform(parameters);
+    const currency = params.currency ? String(params.currency) : null;
+    if (currency) {
+      for (const field of ["shipping", "tax", "subtotal", "total_discount"]) {
+        if (params[field] != null) {
+          params[field] = minorToMajor(Number(params[field]), currency);
+        }
+      }
+    }
+    if (params.contents && Array.isArray(params.contents)) {
+      if (!params.content_ids) {
+        params.content_ids = params.contents.map((i) => i.content_id).filter(Boolean);
+      }
+      params.contents = params.contents.map((item) => {
+        var _a2;
+        const itemCurrency = item.currency ? String(item.currency) : currency;
+        return {
+          content_id: item.content_id,
+          content_name: item.content_name,
+          content_type: (_a2 = item.content_type) != null ? _a2 : "product",
+          content_category: item.content_category,
+          price: item.price != null && itemCurrency ? minorToMajor(Number(item.price), itemCurrency) : item.price != null ? Number(item.price) : void 0,
+          original_price: item.original_price != null && itemCurrency ? minorToMajor(Number(item.original_price), itemCurrency) : item.original_price != null ? Number(item.original_price) : void 0,
+          quantity: item.quantity != null ? Number(item.quantity) : void 0,
+          description: item.description
+        };
+      });
+    }
+    if (eventName === "InitiateCheckout") {
+      params.content_type = (_b = params.content_type) != null ? _b : "product";
+      if (!params.delivery_category) {
+        params.delivery_category = "home_delivery";
+      }
+    }
+    return { name, params };
+  }
+  var SNAPCHAT_EVENT_MAP = {
+    PageView: "PAGE_VIEW",
+    ViewContent: "VIEW_CONTENT",
+    AddToCart: "ADD_CART",
+    AddToWishlist: "ADD_TO_WISHLIST",
+    Search: "SEARCH",
+    InitiateCheckout: "START_CHECKOUT",
+    AddPaymentInfo: "ADD_BILLING",
+    Purchase: "PURCHASE",
+    Lead: "LEAD",
+    CompleteRegistration: "SIGN_UP"
+  };
+  function mapSnapchatEvent(eventName, parameters) {
+    var _a;
+    const name = (_a = SNAPCHAT_EVENT_MAP[eventName]) != null ? _a : eventName;
+    let params = baseTransform(parameters);
+    if ("value" in params) {
+      params = __spreadProps(__spreadValues({}, params), { price: params.value });
+      delete params.value;
+    }
+    if ("num_items" in params) {
+      params = __spreadProps(__spreadValues({}, params), { number_items: params.num_items });
+      delete params.num_items;
+    }
+    if (params.contents && Array.isArray(params.contents)) {
+      params.item_ids = params.contents.map((i) => i.content_id).filter(Boolean);
+    }
+    return { name, params };
+  }
+  var PINTEREST_EVENT_MAP = {
+    PageView: "pagevisit",
+    ViewContent: "viewcontent",
+    AddToCart: "addtocart",
+    AddToWishlist: "addtowishlist",
+    Search: "search",
+    InitiateCheckout: "initiatecheckout",
+    AddPaymentInfo: "addpaymentinfo",
+    Purchase: "checkout",
+    Lead: "lead",
+    CompleteRegistration: "signup"
+  };
+  function mapPinterestEvent(eventName, parameters) {
+    var _a;
+    const name = (_a = PINTEREST_EVENT_MAP[eventName]) != null ? _a : eventName.toLowerCase();
+    const params = baseTransform(parameters);
+    if (params.order_quantity !== void 0) {
+      params.order_quantity = Number(params.order_quantity);
+    }
+    if (params.contents && Array.isArray(params.contents)) {
+      params.line_items = params.contents.map((item) => ({
+        product_id: item.content_id,
+        product_name: item.content_name,
+        product_category: item.content_category,
+        product_price: item.price != null ? Number(item.price) : void 0,
+        product_quantity: item.quantity != null ? Number(item.quantity) : void 0
+      }));
+    }
+    return { name, params };
+  }
+  var GTM_EVENT_MAP = {
+    PageView: "page_view",
+    ViewContent: "view_item",
+    AddToCart: "add_to_cart",
+    AddToWishlist: "add_to_wishlist",
+    Search: "search",
+    InitiateCheckout: "begin_checkout",
+    AddPaymentInfo: "add_payment_info",
+    Purchase: "purchase",
+    Lead: "generate_lead",
+    CompleteRegistration: "sign_up",
+    Conversion: "conversion"
+  };
+  function mapGTMEvent(eventName, parameters) {
+    var _a;
+    const name = (_a = GTM_EVENT_MAP[eventName]) != null ? _a : eventName.toLowerCase();
+    const params = baseTransform(parameters);
+    if (params.num_items !== void 0) {
+      params.num_items = Number(params.num_items);
+    }
+    if (params.contents && Array.isArray(params.contents)) {
+      params.items = params.contents.map((item) => ({
+        item_id: item.content_id,
+        item_name: item.content_name,
+        item_category: item.content_category,
+        price: item.price != null ? Number(item.price) : void 0,
+        quantity: item.quantity != null ? Number(item.quantity) : void 0
+      }));
+      params.contents = params.contents.map((item) => ({
+        id: item.content_id,
+        name: item.content_name,
+        category: item.content_category,
+        price: item.price != null ? Number(item.price) : void 0,
+        quantity: item.quantity != null ? Number(item.quantity) : void 0
+      }));
+    }
+    return { name, params };
+  }
+  function applyGoogleAdsConversion(params, eventName, pixel) {
+    if ((eventName === "Purchase" || eventName === "Conversion") && pixel.googleAdsConversionId && pixel.googleAdsConversionLabel) {
+      return __spreadProps(__spreadValues({}, params), { send_to: "".concat(pixel.googleAdsConversionId, "/").concat(pixel.googleAdsConversionLabel) });
+    }
+    return params;
+  }
+  function resolvePixelEvents(pixels, eventName, parameters) {
+    const results = [];
+    const fb = getEligiblePixels(pixels.facebook, eventName);
+    if (fb.length > 0) {
+      const mapped = mapMetaEvent(eventName, parameters);
+      fb.forEach((pixel) => results.push({ provider: "facebook", mapped, pixel }));
+    }
+    const tt = getEligiblePixels(pixels.tiktok, eventName);
+    if (tt.length > 0) {
+      const mapped = mapTikTokEvent(eventName, parameters);
+      tt.forEach((pixel) => results.push({ provider: "tiktok", mapped, pixel }));
+    }
+    const sc = getEligiblePixels(pixels.snapchat, eventName);
+    if (sc.length > 0) {
+      const mapped = mapSnapchatEvent(eventName, parameters);
+      sc.forEach((pixel) => results.push({ provider: "snapchat", mapped, pixel }));
+    }
+    const pt = getEligiblePixels(pixels.pinterest, eventName);
+    if (pt.length > 0) {
+      const mapped = mapPinterestEvent(eventName, parameters);
+      pt.forEach((pixel) => results.push({ provider: "pinterest", mapped, pixel }));
+    }
+    const gtm = getEligiblePixels(pixels.gtm, eventName);
+    if (gtm.length > 0) {
+      const mapped = mapGTMEvent(eventName, parameters);
+      gtm.forEach((pixel) => {
+        const finalParams = applyGoogleAdsConversion(mapped.params, eventName, pixel);
+        results.push({ provider: "gtm", mapped: { name: mapped.name, params: finalParams }, pixel });
+      });
+    }
+    return results;
+  }
+
   // src/v2/standalone/external-tracker.ts
   init_tokenStorage();
+  var TRACKER_VERSION = "1.0.0";
   function getUrlParam(name) {
     if (typeof window === "undefined") return null;
     const params = new URLSearchParams(window.location.search);
@@ -9924,58 +11622,133 @@ var TagadaSDKBundle = (() => {
       console.log("[TagadaTracker]", ...args);
     }
   }
+  function warn(...args) {
+    console.warn("[TagadaTracker]", ...args);
+  }
+  function validate(config) {
+    if (!config.storeId || typeof config.storeId !== "string") {
+      throw new Error("TagadaTracker: storeId is required and must be a non-empty string.");
+    }
+    if (!config.accountId || typeof config.accountId !== "string") {
+      throw new Error("TagadaTracker: accountId is required and must be a non-empty string.");
+    }
+    if (!config.stepId || typeof config.stepId !== "string") {
+      throw new Error("TagadaTracker: stepId is required and must be a non-empty string.");
+    }
+    if (config.apiBaseUrl) {
+      try {
+        new URL(config.apiBaseUrl);
+      } catch (e) {
+        throw new Error('TagadaTracker: apiBaseUrl is not a valid URL: "'.concat(config.apiBaseUrl, '"'));
+      }
+    }
+  }
+  async function retryWithBackoff(fn, maxRetries, debug) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries) {
+          const delay = Math.min(1e3 * 2 ** attempt, 8e3);
+          log(debug, "Retry ".concat(attempt + 1, "/").concat(maxRetries, " in ").concat(delay, "ms..."));
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
   var TagadaExternalTracker = class {
     constructor() {
       this.config = null;
       this.client = null;
       this.initialized = false;
       this.initializing = false;
+      this.unsubscribe = null;
+      /** Tracker version */
+      this.version = TRACKER_VERSION;
     }
     /**
-     * Initialize the tracker using SDK infrastructure
+     * Initialize the tracker.
+     * When `onError` is provided, errors are passed to the callback and init()
+     * resolves to `null` instead of throwing.
      */
     async init(config) {
-      var _a, _b, _c, _d;
-      if (this.initialized || this.initializing) {
-        log(config.debug || false, "Already initialized or initializing");
+      var _a, _b;
+      if (this.initialized) {
+        log(config.debug || false, "Already initialized \u2014 returning existing session.");
         return this.getSession();
       }
+      if (this.initializing) {
+        log(config.debug || false, "Initialization in progress \u2014 skipping duplicate call.");
+        return null;
+      }
       this.initializing = true;
-      this.config = __spreadValues({
-        debug: false
-      }, config);
-      log(this.config.debug, "\u{1F680} Initializing external tracker with SDK...", config);
+      this.config = __spreadValues({ debug: false }, config);
+      const debug = this.config.debug;
+      try {
+        validate(this.config);
+      } catch (err) {
+        this.initializing = false;
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (this.config.onError) {
+          this.config.onError(error);
+          return null;
+        }
+        throw error;
+      }
+      log(debug, "\u{1F680} Initializing external tracker v".concat(TRACKER_VERSION), {
+        storeId: config.storeId,
+        accountId: config.accountId,
+        stepId: config.stepId,
+        funnelId: config.funnelId
+      });
       try {
         const urlToken = getUrlParam("token");
         if (urlToken) {
           setClientToken(urlToken);
-          log(this.config.debug, "\u{1F511} Bootstrapped token from URL");
+          log(debug, "\u{1F511} Bootstrapped token from URL");
         }
         this.client = createTagadaClient({
-          debugMode: this.config.debug,
-          features: { funnel: true }
+          debugMode: debug,
+          features: { funnel: { skipAutoInit: true } },
+          rawPluginConfig: {
+            storeId: this.config.storeId,
+            accountId: this.config.accountId
+          },
+          customApiConfig: this.config.apiBaseUrl ? {
+            apiConfig: {
+              baseUrl: this.config.apiBaseUrl.trim()
+            }
+          } : void 0
         });
         await this.waitForClientReady();
-        const funnelContext = await this.initializeFunnel();
-        log(this.config.debug, "\u2705 Session initialized (tracking handled by orchestrator):", funnelContext);
+        const funnelContext = await retryWithBackoff(
+          () => this.initializeFunnel(),
+          2,
+          debug
+        );
+        log(debug, "\u2705 Session initialized:", funnelContext);
         this.initialized = true;
         const session = this.getSession();
         if (session) {
           (_b = (_a = this.config).onReady) == null ? void 0 : _b.call(_a, session);
         }
         return session;
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        log(this.config.debug, "\u274C Initialization failed:", err);
-        (_d = (_c = this.config).onError) == null ? void 0 : _d.call(_c, err);
-        throw err;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        log(debug, "\u274C Initialization failed:", error);
+        if (this.config.onError) {
+          this.config.onError(error);
+          return null;
+        }
+        throw error;
       } finally {
         this.initializing = false;
       }
     }
-    /**
-     * Get current session from SDK state
-     */
+    /** Get current session data. */
     getSession() {
       var _a, _b;
       if (!((_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context)) return null;
@@ -9989,19 +11762,18 @@ var TagadaSDKBundle = (() => {
         cmsToken: this.client.state.token || void 0
       };
     }
-    /**
-     * Check if tracker is ready
-     */
+    /** Whether the tracker is fully initialized and ready. */
     isReady() {
       var _a, _b;
       return this.initialized && !!((_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context);
     }
     /**
-     * Navigate to next step in funnel using SDK's funnel client
+     * Navigate to the next step in the funnel.
+     * By default, auto-redirects the browser window.
      */
     async navigate(options) {
       if (!this.isReady()) {
-        throw new Error("Tracker not initialized. Call init() first.");
+        throw new Error("TagadaTracker: not initialized. Call init() first.");
       }
       log(this.config.debug, "\u{1F680} Navigating:", options);
       const shouldAutoRedirect = options.autoRedirect !== false;
@@ -10012,7 +11784,6 @@ var TagadaSDKBundle = (() => {
             data: options.eventData || {}
           },
           { autoRedirect: false }
-          // Always disable SDK auto-redirect, we handle it here
         );
         if (result == null ? void 0 : result.url) {
           log(this.config.debug, "\u2705 Navigation result:", result.url);
@@ -10028,36 +11799,48 @@ var TagadaSDKBundle = (() => {
       }
     }
     /**
-     * Get customer ID (for identifying the user)
+     * Track a custom event (e.g., button click, scroll depth, video play).
+     * Events are sent through the funnel orchestrator for unified analytics.
      */
+    async trackEvent(options) {
+      if (!this.isReady()) {
+        warn("trackEvent called before init \u2014 event dropped:", options.name);
+        return;
+      }
+      log(this.config.debug, "\u{1F4CA} Tracking event:", options.name, options.data);
+      try {
+        await this.client.funnel.navigate(
+          {
+            type: options.name,
+            data: options.data || {}
+          },
+          { autoRedirect: false }
+        );
+      } catch (e) {
+        log(this.config.debug, "\u26A0\uFE0F Event tracking failed (non-critical):", options.name);
+      }
+    }
+    /** Get customer ID. */
     getCustomerId() {
       var _a, _b, _c, _d, _e;
       return ((_b = (_a = this.client) == null ? void 0 : _a.state.auth.customer) == null ? void 0 : _b.id) || ((_e = (_d = (_c = this.client) == null ? void 0 : _c.funnel) == null ? void 0 : _d.state.context) == null ? void 0 : _e.customerId) || null;
     }
-    /**
-     * Get funnel session ID
-     */
+    /** Get funnel session ID. */
     getFunnelSessionId() {
       var _a, _b, _c;
       return ((_c = (_b = (_a = this.client) == null ? void 0 : _a.funnel) == null ? void 0 : _b.state.context) == null ? void 0 : _c.sessionId) || null;
     }
     /**
-     * Build a URL with funnel context parameters
-     * Useful for linking to other external pages while preserving session
+     * Build a URL that preserves funnel session context.
+     * Use this to link to other external pages within the same funnel.
      */
     buildUrl(baseUrl, additionalParams) {
       const session = this.getSession();
-      if (!session) {
-        return baseUrl;
-      }
+      if (!session) return baseUrl;
       const url = new URL(baseUrl, typeof window !== "undefined" ? window.location.origin : void 0);
       url.searchParams.set("funnelSessionId", session.sessionId);
-      if (session.cmsToken) {
-        url.searchParams.set("token", session.cmsToken);
-      }
-      if (session.funnelId) {
-        url.searchParams.set("funnelId", session.funnelId);
-      }
+      if (session.cmsToken) url.searchParams.set("token", session.cmsToken);
+      if (session.funnelId) url.searchParams.set("funnelId", session.funnelId);
       url.searchParams.set("storeId", session.storeId);
       if (additionalParams) {
         Object.entries(additionalParams).forEach(([key, value]) => {
@@ -10066,55 +11849,98 @@ var TagadaSDKBundle = (() => {
       }
       return url.toString();
     }
-    /**
-     * Get the underlying SDK client (for advanced usage)
-     */
+    /** Get the underlying SDK client (advanced usage). */
     getClient() {
       return this.client;
     }
+    /**
+     * Reset the tracker to a new step without re-creating the session.
+     * Useful for SPAs that navigate between funnel steps client-side.
+     */
+    async reset(newStepId) {
+      var _a, _b;
+      if (!this.client || !this.config) {
+        throw new Error("TagadaTracker: not initialized. Call init() first.");
+      }
+      log(this.config.debug, "\u{1F504} Resetting to step:", newStepId);
+      this.config.stepId = newStepId;
+      const ctx = await this.initializeFunnel();
+      const session = this.getSession();
+      if (session) (_b = (_a = this.config).onReady) == null ? void 0 : _b.call(_a, session);
+      return session;
+    }
+    /**
+     * Destroy the tracker, clean up event listeners and state.
+     * Call this when the tracker is no longer needed (e.g., SPA teardown).
+     */
+    destroy() {
+      var _a, _b;
+      if (this.unsubscribe) {
+        this.unsubscribe();
+        this.unsubscribe = null;
+      }
+      if (this.client) {
+        (_b = (_a = this.client).destroy) == null ? void 0 : _b.call(_a);
+      }
+      this.client = null;
+      this.config = null;
+      this.initialized = false;
+      this.initializing = false;
+      log(false, "\u{1F5D1}\uFE0F Tracker destroyed");
+    }
     // ========================================================================
     // PRIVATE METHODS
     // ========================================================================
     async waitForClientReady() {
       if (!this.client) return;
       return new Promise((resolve) => {
-        let retries = 0;
-        const checkReady = () => {
-          var _a, _b;
-          if (((_a = this.client) == null ? void 0 : _a.state.isInitialized) || ((_b = this.client) == null ? void 0 : _b.state.token)) {
+        var _a;
+        if ((_a = this.client) == null ? void 0 : _a.state.isInitialized) {
+          resolve();
+          return;
+        }
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          var _a2;
+          if (!resolved) {
+            resolved = true;
+            log(((_a2 = this.config) == null ? void 0 : _a2.debug) || false, "\u23F1\uFE0F Client ready timeout \u2014 proceeding");
             resolve();
-          } else if (retries > 40) {
+          }
+        }, 1e4);
+        this.unsubscribe = this.client.subscribe(() => {
+          var _a2;
+          if (!resolved && ((_a2 = this.client) == null ? void 0 : _a2.state.isInitialized)) {
+            resolved = true;
+            clearTimeout(timeout);
             resolve();
-          } else {
-            retries++;
-            setTimeout(checkReady, 50);
           }
-        };
-        checkReady();
+        });
       });
     }
     async initializeFunnel() {
       var _a, _b, _c;
       if (!((_a = this.client) == null ? void 0 : _a.funnel)) return null;
+      const customerId = (_b = this.client.state.auth.customer) == null ? void 0 : _b.id;
+      const sessionId = (_c = this.client.state.auth.session) == null ? void 0 : _c.sessionId;
+      if (!customerId && !sessionId) {
+        warn("No auth session available \u2014 funnel init may fail.");
+      }
       const authSession = {
-        customerId: ((_b = this.client.state.auth.customer) == null ? void 0 : _b.id) || "anon_placeholder",
-        sessionId: ((_c = this.client.state.auth.session) == null ? void 0 : _c.sessionId) || "sess_placeholder"
+        customerId: customerId || "anon_placeholder",
+        sessionId: sessionId || "sess_placeholder"
       };
       const store = {
         id: this.config.storeId,
-        accountId: this.config.accountId || ""
+        accountId: this.config.accountId
       };
       const entryStepId = this.config.stepId;
-      if (!entryStepId) {
-        throw new Error("stepId is required for external page tracking (URL mapping does not work for external pages)");
-      }
-      log(this.config.debug, "\u{1F50D} Initializing external page at step:", entryStepId);
+      log(this.config.debug, "\u{1F50D} Initializing funnel at step:", entryStepId);
       return this.client.funnel.initialize(
         authSession,
         store,
         this.config.funnelId || getUrlParam("funnelId") || void 0,
         entryStepId
-        // ✅ Explicitly tell orchestrator which step we're on
       );
     }
   };
@@ -10124,6 +11950,79 @@ var TagadaSDKBundle = (() => {
   }
 
   // src/v2/standalone/index.ts
+  function parseStepConfigScripts() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return [];
+    }
+    const stepConfig = getAssignedStepConfig();
+    if (stepConfig == null ? void 0 : stepConfig.scripts) {
+      return stepConfig.scripts.filter((s) => s.enabled);
+    }
+    return [];
+  }
+  function injectScript(script, index) {
+    const position = script.position || "body-end";
+    const scriptId = "tagada-stepconfig-script-".concat(index);
+    if (document.getElementById(scriptId)) {
+      return;
+    }
+    let scriptBody = script.content.trim();
+    const scriptTagMatch = scriptBody.match(/^<script[^>]*>([\s\S]*)<\/script>$/i);
+    if (scriptTagMatch) {
+      scriptBody = scriptTagMatch[1].trim();
+    }
+    if (!scriptBody) return;
+    const wrappedScript = "(function() {\n  try {\n    // Script: " + script.name + "\n" + scriptBody + '\n  } catch (error) {\n    console.error("[TagadaPay] StepConfig script error:", error);\n  }\n})();';
+    const scriptElement = document.createElement("script");
+    scriptElement.id = scriptId;
+    scriptElement.setAttribute("data-tagada-stepconfig-script", "true");
+    scriptElement.setAttribute("data-script-name", script.name);
+    scriptElement.textContent = wrappedScript;
+    switch (position) {
+      case "head-start":
+        if (document.head.firstChild) {
+          document.head.insertBefore(scriptElement, document.head.firstChild);
+        } else {
+          document.head.appendChild(scriptElement);
+        }
+        break;
+      case "head-end":
+        document.head.appendChild(scriptElement);
+        break;
+      case "body-start":
+        if (document.body.firstChild) {
+          document.body.insertBefore(scriptElement, document.body.firstChild);
+        } else {
+          document.body.appendChild(scriptElement);
+        }
+        break;
+      case "body-end":
+      default:
+        document.body.appendChild(scriptElement);
+        break;
+    }
+  }
+  function injectStepConfigScripts() {
+    const scripts = parseStepConfigScripts();
+    if (scripts.length === 0) return;
+    scripts.forEach((script, index) => {
+      injectScript(script, index);
+    });
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    const runInjection = () => {
+      if (document.body) {
+        injectStepConfigScripts();
+      } else {
+        document.addEventListener("DOMContentLoaded", injectStepConfigScripts, { once: true });
+      }
+    };
+    if ("requestIdleCallback" in window) {
+      window.requestIdleCallback(runInjection, { timeout: 100 });
+    } else {
+      setTimeout(runInjection, 0);
+    }
+  }
   function createTagadaClient(config = {}) {
     return new TagadaClient(config);
   }
@@ -10162,5 +12061,6 @@ if (typeof window !== 'undefined' && TagadaSDKBundle) {
   window.tgd.sendConfigUpdate = TagadaSDKBundle.sendConfigUpdate;
   window.tgd.broadcastConfigUpdate = TagadaSDKBundle.broadcastConfigUpdate;
   window.tgd.formatMoney = TagadaSDKBundle.formatMoney;
+  window.tgd.injectStepConfigScripts = TagadaSDKBundle.injectStepConfigScripts;
   window.tgd.sdk = TagadaSDKBundle;
 }