@goodgamestudios/cxf-webshop 7.0.0-qa.8 → 7.0.0

package/cdn.jsdelivr.net/npm/@goodgamestudios/cxf-webshop@qa/dist/webshop-cxf.js

@@ -0,0 +1,1499 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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 __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    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
+  ));
+
+  // <define:process>
+  var define_process_default;
+  var init_define_process = __esm({
+    "<define:process>"() {
+      define_process_default = { env: { BASE_URL: "http://localhost:1101", CANVAS_AGENT_URL: "https://app-dev.canvas.stillfront.com/agent.js", CANVAS_APP_ID_BY_GAME: { "12": "dae760ab-b773-4c1a-ae99-7633f12ec7d5", "15": "d57bb239-6e02-4e17-8148-0a10c4dd75f6", "16": "18f5521d-7df2-4bb3-88a3-c162ba072d73" }, CUSTOMIZATION_URL_TEMPLATE: "https://cdn.jsdelivr.net/npm/@lemonstand.org/config-goodgamestudios@{1}/dist/goodgamestudios-{0}.json", CUSTOMIZATION_URL: "https://cdn.jsdelivr.net/npm/@lemonstand.org/config-goodgamestudios@qa/dist/goodgamestudios-{0}.json" } };
+    }
+  });
+
+  // node_modules/debug/node_modules/ms/index.js
+  var require_ms = __commonJS({
+    "node_modules/debug/node_modules/ms/index.js"(exports, module) {
+      init_define_process();
+      var s = 1e3;
+      var m = s * 60;
+      var h = m * 60;
+      var d = h * 24;
+      var w = d * 7;
+      var y = d * 365.25;
+      module.exports = function(val, options) {
+        options = options || {};
+        var type = typeof val;
+        if (type === "string" && val.length > 0) {
+          return parse(val);
+        } else if (type === "number" && isFinite(val)) {
+          return options.long ? fmtLong(val) : fmtShort(val);
+        }
+        throw new Error(
+          "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+        );
+      };
+      function parse(str) {
+        str = String(str);
+        if (str.length > 100) {
+          return;
+        }
+        var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+          str
+        );
+        if (!match) {
+          return;
+        }
+        var n = parseFloat(match[1]);
+        var type = (match[2] || "ms").toLowerCase();
+        switch (type) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return n * y;
+          case "weeks":
+          case "week":
+          case "w":
+            return n * w;
+          case "days":
+          case "day":
+          case "d":
+            return n * d;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return n * h;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return n * m;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return n * s;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return n;
+          default:
+            return void 0;
+        }
+      }
+      function fmtShort(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return Math.round(ms / d) + "d";
+        }
+        if (msAbs >= h) {
+          return Math.round(ms / h) + "h";
+        }
+        if (msAbs >= m) {
+          return Math.round(ms / m) + "m";
+        }
+        if (msAbs >= s) {
+          return Math.round(ms / s) + "s";
+        }
+        return ms + "ms";
+      }
+      function fmtLong(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return plural(ms, msAbs, d, "day");
+        }
+        if (msAbs >= h) {
+          return plural(ms, msAbs, h, "hour");
+        }
+        if (msAbs >= m) {
+          return plural(ms, msAbs, m, "minute");
+        }
+        if (msAbs >= s) {
+          return plural(ms, msAbs, s, "second");
+        }
+        return ms + " ms";
+      }
+      function plural(ms, msAbs, n, name) {
+        var isPlural = msAbs >= n * 1.5;
+        return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+      }
+    }
+  });
+
+  // node_modules/debug/src/common.js
+  var require_common = __commonJS({
+    "node_modules/debug/src/common.js"(exports, module) {
+      init_define_process();
+      function setup(env) {
+        createDebug.debug = createDebug;
+        createDebug.default = createDebug;
+        createDebug.coerce = coerce;
+        createDebug.disable = disable;
+        createDebug.enable = enable;
+        createDebug.enabled = enabled;
+        createDebug.humanize = require_ms();
+        createDebug.destroy = destroy;
+        Object.keys(env).forEach((key) => {
+          createDebug[key] = env[key];
+        });
+        createDebug.names = [];
+        createDebug.skips = [];
+        createDebug.formatters = {};
+        function selectColor(namespace) {
+          let hash = 0;
+          for (let i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0;
+          }
+          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+        }
+        createDebug.selectColor = selectColor;
+        function createDebug(namespace) {
+          let prevTime;
+          let enableOverride = null;
+          let namespacesCache;
+          let enabledCache;
+          function debug2(...args) {
+            if (!debug2.enabled) {
+              return;
+            }
+            const self = debug2;
+            const curr = Number(/* @__PURE__ */ new Date());
+            const ms = curr - (prevTime || curr);
+            self.diff = ms;
+            self.prev = prevTime;
+            self.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+            if (typeof args[0] !== "string") {
+              args.unshift("%O");
+            }
+            let index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+              if (match === "%%") {
+                return "%";
+              }
+              index++;
+              const formatter = createDebug.formatters[format];
+              if (typeof formatter === "function") {
+                const val = args[index];
+                match = formatter.call(self, val);
+                args.splice(index, 1);
+                index--;
+              }
+              return match;
+            });
+            createDebug.formatArgs.call(self, args);
+            const logFn = self.log || createDebug.log;
+            logFn.apply(self, args);
+          }
+          debug2.namespace = namespace;
+          debug2.useColors = createDebug.useColors();
+          debug2.color = createDebug.selectColor(namespace);
+          debug2.extend = extend;
+          debug2.destroy = createDebug.destroy;
+          Object.defineProperty(debug2, "enabled", {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              if (enableOverride !== null) {
+                return enableOverride;
+              }
+              if (namespacesCache !== createDebug.namespaces) {
+                namespacesCache = createDebug.namespaces;
+                enabledCache = createDebug.enabled(namespace);
+              }
+              return enabledCache;
+            },
+            set: (v) => {
+              enableOverride = v;
+            }
+          });
+          if (typeof createDebug.init === "function") {
+            createDebug.init(debug2);
+          }
+          return debug2;
+        }
+        function extend(namespace, delimiter) {
+          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+          newDebug.log = this.log;
+          return newDebug;
+        }
+        function enable(namespaces) {
+          createDebug.save(namespaces);
+          createDebug.namespaces = namespaces;
+          createDebug.names = [];
+          createDebug.skips = [];
+          const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+          for (const ns of split) {
+            if (ns[0] === "-") {
+              createDebug.skips.push(ns.slice(1));
+            } else {
+              createDebug.names.push(ns);
+            }
+          }
+        }
+        function matchesTemplate(search, template) {
+          let searchIndex = 0;
+          let templateIndex = 0;
+          let starIndex = -1;
+          let matchIndex = 0;
+          while (searchIndex < search.length) {
+            if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+              if (template[templateIndex] === "*") {
+                starIndex = templateIndex;
+                matchIndex = searchIndex;
+                templateIndex++;
+              } else {
+                searchIndex++;
+                templateIndex++;
+              }
+            } else if (starIndex !== -1) {
+              templateIndex = starIndex + 1;
+              matchIndex++;
+              searchIndex = matchIndex;
+            } else {
+              return false;
+            }
+          }
+          while (templateIndex < template.length && template[templateIndex] === "*") {
+            templateIndex++;
+          }
+          return templateIndex === template.length;
+        }
+        function disable() {
+          const namespaces = [
+            ...createDebug.names,
+            ...createDebug.skips.map((namespace) => "-" + namespace)
+          ].join(",");
+          createDebug.enable("");
+          return namespaces;
+        }
+        function enabled(name) {
+          for (const skip of createDebug.skips) {
+            if (matchesTemplate(name, skip)) {
+              return false;
+            }
+          }
+          for (const ns of createDebug.names) {
+            if (matchesTemplate(name, ns)) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function coerce(val) {
+          if (val instanceof Error) {
+            return val.stack || val.message;
+          }
+          return val;
+        }
+        function destroy() {
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+        createDebug.enable(createDebug.load());
+        return createDebug;
+      }
+      module.exports = setup;
+    }
+  });
+
+  // node_modules/debug/src/browser.js
+  var require_browser = __commonJS({
+    "node_modules/debug/src/browser.js"(exports, module) {
+      init_define_process();
+      exports.formatArgs = formatArgs;
+      exports.save = save;
+      exports.load = load;
+      exports.useColors = useColors;
+      exports.storage = localstorage();
+      exports.destroy = /* @__PURE__ */ (() => {
+        let warned = false;
+        return () => {
+          if (!warned) {
+            warned = true;
+            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+          }
+        };
+      })();
+      exports.colors = [
+        "#0000CC",
+        "#0000FF",
+        "#0033CC",
+        "#0033FF",
+        "#0066CC",
+        "#0066FF",
+        "#0099CC",
+        "#0099FF",
+        "#00CC00",
+        "#00CC33",
+        "#00CC66",
+        "#00CC99",
+        "#00CCCC",
+        "#00CCFF",
+        "#3300CC",
+        "#3300FF",
+        "#3333CC",
+        "#3333FF",
+        "#3366CC",
+        "#3366FF",
+        "#3399CC",
+        "#3399FF",
+        "#33CC00",
+        "#33CC33",
+        "#33CC66",
+        "#33CC99",
+        "#33CCCC",
+        "#33CCFF",
+        "#6600CC",
+        "#6600FF",
+        "#6633CC",
+        "#6633FF",
+        "#66CC00",
+        "#66CC33",
+        "#9900CC",
+        "#9900FF",
+        "#9933CC",
+        "#9933FF",
+        "#99CC00",
+        "#99CC33",
+        "#CC0000",
+        "#CC0033",
+        "#CC0066",
+        "#CC0099",
+        "#CC00CC",
+        "#CC00FF",
+        "#CC3300",
+        "#CC3333",
+        "#CC3366",
+        "#CC3399",
+        "#CC33CC",
+        "#CC33FF",
+        "#CC6600",
+        "#CC6633",
+        "#CC9900",
+        "#CC9933",
+        "#CCCC00",
+        "#CCCC33",
+        "#FF0000",
+        "#FF0033",
+        "#FF0066",
+        "#FF0099",
+        "#FF00CC",
+        "#FF00FF",
+        "#FF3300",
+        "#FF3333",
+        "#FF3366",
+        "#FF3399",
+        "#FF33CC",
+        "#FF33FF",
+        "#FF6600",
+        "#FF6633",
+        "#FF9900",
+        "#FF9933",
+        "#FFCC00",
+        "#FFCC33"
+      ];
+      function useColors() {
+        if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+          return true;
+        }
+        if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+          return false;
+        }
+        let m;
+        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+        typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+        typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+        typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+      }
+      function formatArgs(args) {
+        args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+        if (!this.useColors) {
+          return;
+        }
+        const c = "color: " + this.color;
+        args.splice(1, 0, c, "color: inherit");
+        let index = 0;
+        let lastC = 0;
+        args[0].replace(/%[a-zA-Z%]/g, (match) => {
+          if (match === "%%") {
+            return;
+          }
+          index++;
+          if (match === "%c") {
+            lastC = index;
+          }
+        });
+        args.splice(lastC, 0, c);
+      }
+      exports.log = console.debug || console.log || (() => {
+      });
+      function save(namespaces) {
+        try {
+          if (namespaces) {
+            exports.storage.setItem("debug", namespaces);
+          } else {
+            exports.storage.removeItem("debug");
+          }
+        } catch (error) {
+        }
+      }
+      function load() {
+        let r;
+        try {
+          r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+        } catch (error) {
+        }
+        if (!r && typeof define_process_default !== "undefined" && "env" in define_process_default) {
+          r = define_process_default.env.DEBUG;
+        }
+        return r;
+      }
+      function localstorage() {
+        try {
+          return localStorage;
+        } catch (error) {
+        }
+      }
+      module.exports = require_common()(exports);
+      var { formatters } = module.exports;
+      formatters.j = function(v) {
+        try {
+          return JSON.stringify(v);
+        } catch (error) {
+          return "[UnexpectedJSONParseError]: " + error.message;
+        }
+      };
+    }
+  });
+
+  // node_modules/@goodgamestudios/cxf-ready/dist/index.js
+  var require_dist = __commonJS({
+    "node_modules/@goodgamestudios/cxf-ready/dist/index.js"(exports, module) {
+      "use strict";
+      init_define_process();
+      var cxf = window && window.CXF;
+      module.exports = new Promise(function(resolve, reject) {
+        if (!window) {
+          reject();
+        }
+        if (cxf) {
+          return resolve(cxf);
+        }
+        window.addEventListener("cxf.initialized", function(event) {
+          cxf = event.cxf;
+          resolve(cxf);
+        }, {
+          capture: true,
+          once: true,
+          passive: true
+        });
+      });
+    }
+  });
+
+  // node_modules/@goodgamestudios/game-alias/dist/index.js
+  var require_dist2 = __commonJS({
+    "node_modules/@goodgamestudios/game-alias/dist/index.js"(exports, module) {
+      init_define_process();
+      (function() {
+        var b = {};
+        function f(r, $) {
+          return h(r) || g(r, $) || e();
+        }
+        function e() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance");
+        }
+        function g(r, $) {
+          var a2 = [], o2 = true, e2 = false, n2 = void 0;
+          try {
+            for (var c2, i2 = r[Symbol.iterator](); !(o2 = (c2 = i2.next()).done) && (a2.push(c2.value), !$ || a2.length !== $); o2 = true) ;
+          } catch (m2) {
+            e2 = true, n2 = m2;
+          } finally {
+            try {
+              o2 || null == i2.return || i2.return();
+            } finally {
+              if (e2) throw n2;
+            }
+          }
+          return a2;
+        }
+        function h(r) {
+          if (Array.isArray(r)) return r;
+        }
+        var i = 0, j = 1, k = 2, c = { 1: ["poker", "poker2", "poker"], 12: ["empire", "castle", "em"], 15: ["bigfarm", "ranch", "bf"], 16: ["empirefourkingdoms", "fourkingdoms", "e4k"], 23: ["legendsofhonor", void 0, "loh"], 41: ["empiremillenniumwars", void 0, "emmw"] }, d = Object.entries(c).reduce(function(r, $) {
+          var a2 = f($, 2), o2 = a2[0], e2 = a2[1];
+          return o2 = parseInt(o2, 10), r[o2] = o2, e2.forEach(function($2) {
+            r[$2] = o2;
+          }), r;
+        }, {}), l = function(r) {
+          r = r.toString().toLowerCase();
+          var $ = d[r];
+          return $ && 0 | $;
+        }, a = function(r, $) {
+          return ($ = d[$]) && c[$][r];
+        }, m = a.bind(null, i), n = a.bind(null, j), o = a.bind(null, k);
+        b = { id: l, name: m, codename: n, acronym: o };
+        if (typeof exports === "object" && typeof module !== "undefined") {
+          module.exports = b;
+        } else if (typeof define === "function" && define.amd) {
+          define(function() {
+            return b;
+          });
+        }
+      })();
+    }
+  });
+
+  // node_modules/@goodgamestudios/cxf-events/dist/typings.js
+  var require_typings = __commonJS({
+    "node_modules/@goodgamestudios/cxf-events/dist/typings.js"(exports) {
+      "use strict";
+      init_define_process();
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.CxfEvents = void 0;
+      var CxfEvents3;
+      (function(CxfEvents4) {
+        CxfEvents4["Token"] = "cxf.token";
+        CxfEvents4["Login"] = "cxf.login";
+        CxfEvents4["Signup"] = "cxf.signup";
+        CxfEvents4["GameEventUpdate"] = "cxf.gameEvent.update";
+        CxfEvents4["GameEventAdd"] = "cxf.gameEvent.add";
+        CxfEvents4["GameEventRemove"] = "cxf.gameEvent.remove";
+        CxfEvents4["XpChanged"] = "cxf.xp.changed";
+        CxfEvents4["LevelChanged"] = "cxf.level.changed";
+        CxfEvents4["LegendLevelChanged"] = "cxf.legendLevel.changed";
+        CxfEvents4["Push"] = "cxf.push";
+        CxfEvents4["OpenIGS"] = "cxf.igs.open";
+        CxfEvents4["JoinTempServer"] = "cxf.join.temp.server";
+        CxfEvents4["Subscription"] = "cxf.subscription";
+        CxfEvents4["RewardedAdStart"] = "cxf.rewardedad.start";
+        CxfEvents4["RewardedAdDone"] = "cxf.rewardedad.done";
+      })(CxfEvents3 = exports.CxfEvents || (exports.CxfEvents = {}));
+    }
+  });
+
+  // src/index.ts
+  init_define_process();
+
+  // src/app.ts
+  init_define_process();
+
+  // src/globalState.ts
+  init_define_process();
+
+  // src/fetch.ts
+  init_define_process();
+
+  // src/helpers.ts
+  init_define_process();
+
+  // node_modules/@lukeed/uuid/dist/index.mjs
+  init_define_process();
+  var IDX = 256;
+  var HEX = [];
+  var BUFFER;
+  while (IDX--) HEX[IDX] = (IDX + 256).toString(16).substring(1);
+  function v4() {
+    var i = 0, num, out = "";
+    if (!BUFFER || IDX + 16 > 256) {
+      BUFFER = Array(i = 256);
+      while (i--) BUFFER[i] = 256 * Math.random() | 0;
+      i = IDX = 0;
+    }
+    for (; i < 16; i++) {
+      num = BUFFER[IDX + i];
+      if (i == 6) out += HEX[num & 15 | 64];
+      else if (i == 8) out += HEX[num & 63 | 128];
+      else out += HEX[num];
+      if (i & 1 && i > 1 && i < 11) out += "-";
+    }
+    IDX++;
+    return out;
+  }
+
+  // src/helpers.ts
+  var import_debug = __toESM(require_browser());
+
+  // src/ArgumentNullError.ts
+  init_define_process();
+  var ArgumentNullError = class extends Error {
+    constructor(parameterName, parameterValue) {
+      super(`${parameterName} has null value: ${parameterValue}`);
+      this.name = "ArgumentNullError";
+    }
+  };
+
+  // src/types/models.ts
+  init_define_process();
+  function encodeGnip({ gameId, networkId, instanceId, playerId }) {
+    return [gameId, networkId, instanceId, playerId].join("-");
+  }
+
+  // src/utils.ts
+  init_define_process();
+  var startTimer = (function_, time) => {
+    const id = setTimeout(function_, time);
+    return () => clearTimeout(id);
+  };
+  var timeout = (function_, time) => (a) => {
+    return new Promise((resolve, reject) => {
+      const stopTimer = startTimer(() => {
+        reject(new Error(`Timeout has exceeded ${time}`));
+      }, time);
+      function_(a).then((value) => {
+        resolve(value);
+        stopTimer();
+      }).catch(reject);
+    });
+  };
+  var validateForNull = (properties) => {
+    for (const key of Object.keys(properties)) {
+      const value = properties[key];
+      if (value === void 0 || value === null || Number.isNaN(value)) {
+        throw new ArgumentNullError(key, value);
+      }
+    }
+  };
+  function msToSec(value) {
+    return Math.floor(value / 1e3);
+  }
+  var parentDomain = (referrer) => {
+    const matches = referrer.match(/^https?:\/\/([^#/?]+)(?:[#/?]|$)/i);
+    if (!matches || !matches[1]) {
+      return;
+    }
+    const result = matches[1].match(/[^.]+\.[^.]+$/);
+    if (!result) {
+      return;
+    }
+    return result[0];
+  };
+
+  // src/helpers.ts
+  var detectPlatform = (defaultPlatform = "stillpay") => {
+    const nativePlatform = navigator.userAgent.match(
+      /(itunes)|(googleplay)|(Android)|(amazonmobile)|(facebook)|(samsung)|(huawei)/g
+    );
+    if (!nativePlatform) return defaultPlatform;
+    const activePlatform = nativePlatform[0];
+    const distribPlatforms = {
+      itunes: "apple",
+      Android: "google",
+      googleplay: "google",
+      amazonmobile: "amazon",
+      facebook: "facebook",
+      samsung: "samsung",
+      huawei: "huawei"
+    };
+    return Object.prototype.hasOwnProperty.call(distribPlatforms, activePlatform) ? distribPlatforms[activePlatform] : defaultPlatform;
+  };
+  function formatQueryString(object) {
+    return Object.entries(object).filter(([key, value]) => value !== null && value !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+  }
+  var getTokenAndLanguage = (store) => {
+    const { playerId, token, zoneId, language } = store;
+    if (!playerId) {
+      throw new ArgumentNullError("playerId", playerId);
+    }
+    return {
+      token,
+      zoneId,
+      locale: language,
+      ping: encodeGnip({ ...store, playerId })
+    };
+  };
+  var loadScript = (src) => new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.type = "module";
+    script.async = true;
+    script.src = src;
+    script.addEventListener("load", resolve);
+    script.addEventListener("error", reject);
+    document.body.append(script);
+  });
+  var tryCatch = (fn) => (...args) => {
+    try {
+      return fn(...args);
+    } catch (error) {
+      logError(error);
+      throwCxfError(error);
+    }
+  };
+  var throwCxfError = (e) => {
+    const config = globalState.getConfig();
+    const cxf = globalState.getCxf();
+    cxf.emit(config.CXF_ERROR, e);
+  };
+  var loadCxf = timeout(() => require_dist(), 1e4);
+  var logger = (0, import_debug.default)("CXF-WEBSHOP");
+  var log = (argument0, ...rest) => logger(argument0, ...rest);
+  var logError = (...arguments_) => (
+    // tslint:disable-next-line:no-console
+    console.error("%c CXF-WEBSHOP ->", "background: #ff0000; color: #fff", ...arguments_)
+  );
+  var createSessionId = () => v4();
+  var getDomain = (referrer) => {
+    return parentDomain(referrer);
+  };
+  var ggsGetQueryParams = () => {
+    return ggsGetQueryParameters();
+  };
+  var ggsGetReferrerValue = () => {
+    return ggsGetReferrer();
+  };
+  var transformPaymentContractIdsToNativePriceEvent = (ids) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    ids.reduce(
+      (prev, cur, idx) => {
+        prev.offers.push({
+          id: cur,
+          tier: 0,
+          productIds: {
+            googleplay: cur
+          }
+        });
+        return prev;
+      },
+      {
+        category: "all",
+        offers: [],
+        eventName: "lemonstand.nativePrice",
+        eventType: "bubble"
+      }
+    )
+  );
+
+  // src/store.ts
+  init_define_process();
+  function initializeStore(cxf) {
+    return {
+      isCanvas: false,
+      playerId: cxf.playerId,
+      instanceId: cxf.instanceId,
+      networkId: cxf.networkId,
+      gameId: cxf.gameId,
+      gameApi: cxf.gameApi,
+      language: cxf.language,
+      token: cxf.token,
+      zoneId: cxf.zoneId,
+      gameEvents: [],
+      xp: 0,
+      level: 0,
+      legendLevel: void 0,
+      countryCode: "",
+      lastPurchaseTab: "",
+      subscriptionDisabled: false,
+      isTempServer: false,
+      customizationSuffix: "",
+      resolvedCustomizationUrl: "",
+      sourceId: "unknown",
+      unreadOfferNotifsCountUrl: ""
+    };
+  }
+  function criteriaSelector({ legendLevel, level }) {
+    return {
+      legendLevel,
+      level
+    };
+  }
+
+  // src/fetch.ts
+  var fetchUnreadOfferNotificationsCount = async () => {
+    const config = globalState.getConfig();
+    const store = globalState.getStore();
+    if (config.LEGEND_LEVEL_IS_USED && store.legendLevel === void 0) {
+      log("Skip fetchUnreadOfferNotificationsCount due to legendLevel is undefined");
+      return;
+    }
+    if (!store.isCanvas && store.token && store.unreadOfferNotifsCountUrl) {
+      log("fetchUnreadOfferNotificationsCount");
+      let unreadCount = 0;
+      const headers = {
+        Authorization: `Bearer ${store.token}`
+      };
+      const url = store.unreadOfferNotifsCountUrl.replace("{locale}", store.language || "").replace("{zoneId}", store.zoneId || "").replace("{criteria}", encodeURIComponent(JSON.stringify(criteriaSelector(store))));
+      try {
+        log("fetch", url);
+        const resp = await fetch(url, {
+          headers
+        });
+        if (resp.ok) {
+          const data = await resp.json();
+          unreadCount = Number(data?.notifCount);
+        }
+      } catch (error) {
+        logError(`cannot fetch ${url}`, error);
+      }
+      log("setUnseenOffersCounter", unreadCount);
+      store.gameApi.invokeFn("setUnseenOffersCounter", unreadCount).catch((error) => {
+        logError("setUnseenOffersCounter error:", error);
+      });
+    }
+  };
+
+  // src/messages/ShopMessageBus.ts
+  init_define_process();
+  var ShopMessageBus = class {
+    post(message) {
+      const element = document.querySelector("#dialog");
+      if (element && element.tagName.toLocaleLowerCase() === "iframe") {
+        element.contentWindow?.postMessage(message, "*");
+      }
+    }
+  };
+
+  // src/preFetch.ts
+  init_define_process();
+
+  // src/url.ts
+  init_define_process();
+  var import_game_alias = __toESM(require_dist2());
+  var createIframeUrl = ({ page, route, sid, config: igsConfig = {} }) => {
+    const config = globalState.getConfig();
+    const store = globalState.getStore();
+    const { token, zoneId, locale } = getTokenAndLanguage(store);
+    const parameters = {
+      token,
+      zoneId,
+      locale,
+      sid: sid || createSessionId()
+    };
+    if (Object.keys(igsConfig).length > 0) {
+      parameters.config = JSON.stringify(igsConfig);
+    }
+    validateForNull(parameters);
+    const urlParameters = new URLSearchParams(ggsGetQueryParams());
+    const queryParameters = {
+      ...parameters,
+      "lemonstand.customization.url": store.resolvedCustomizationUrl || createCustomizationUrl(),
+      domain: getDomain(ggsGetReferrerValue()),
+      websiteId: urlParameters.get("w"),
+      criteria: JSON.stringify(criteriaSelector(store)),
+      level: store.level
+    };
+    const network = urlParameters.get("network");
+    if (urlParameters.get("usekeybaselogin") === "false" && Number(network) > 0) {
+      queryParameters.network = network;
+    }
+    if (store.adStatus?.areBannersAvailable) {
+      queryParameters.ads = true;
+    }
+    return `${config.BASE_URL}/?${formatQueryString(queryParameters)}${page ? `#${page}` : ""}${route ? `--${route}--${Date.now()}` : ""}`;
+  };
+  var createCustomizationUrl = () => {
+    const config = globalState.getConfig();
+    const store = globalState.getStore();
+    const cxf = globalState.getCxf();
+    const configBase = (0, import_game_alias.acronym)(store.gameId);
+    const configVariance = store.customizationSuffix ? `-${store.customizationSuffix}` : "";
+    const configBranch = `${configBase}${configVariance}`;
+    if (cxf.env === "test") {
+      const configVersion = new URLSearchParams(window.location.search).get("configGGS");
+      if (configVersion !== null) {
+        return config.CUSTOMIZATION_URL_TEMPLATE.replace("{0}", configBranch).replace("{1}", configVersion);
+      }
+    }
+    return config.CUSTOMIZATION_URL.replace("{0}", configBranch);
+  };
+
+  // src/preFetch.ts
+  var preResolveConfig = () => {
+    if (typeof fetch !== "function") {
+      return;
+    }
+    const originalCustomUrl = createCustomizationUrl();
+    let resolvedUrl = "";
+    fetch(originalCustomUrl).then((resp) => {
+      const currentCustomUrl = createCustomizationUrl();
+      if (currentCustomUrl === originalCustomUrl) {
+        resolvedUrl = resp.url;
+        log("parsed customization url is " + resolvedUrl);
+        globalState.updateStore({
+          resolvedCustomizationUrl: resolvedUrl
+        });
+        return resp.json();
+      }
+    }).then((config) => {
+      if (config) {
+        globalState.updateStore({
+          unreadOfferNotifsCountUrl: config.unreadOfferNotifsCountUrl || ""
+        });
+      }
+    });
+  };
+
+  // src/types/store.ts
+  init_define_process();
+  var entityProvider = (initial) => {
+    let element = initial;
+    return {
+      get: () => element,
+      set: (value) => {
+        element = value;
+      }
+    };
+  };
+
+  // src/globalState.ts
+  var GlobalState = class {
+    constructor() {
+      this.config = void 0;
+      this.cxfProvider = entityProvider();
+      this.dialogProvider = entityProvider();
+      this.storeProvider = entityProvider();
+      this.shopMessageBus = new ShopMessageBus();
+      this.fetchUnreadOfferNotificationsCount = fetchUnreadOfferNotificationsCount;
+      this.preResolveConfig = preResolveConfig;
+    }
+    setConfig(config) {
+      this.config = config;
+    }
+    getConfig() {
+      if (this.config === void 0) {
+        throw new Error("Config is not initialized");
+      }
+      return this.config;
+    }
+    setCxf(cxf) {
+      this.cxfProvider.set(cxf);
+    }
+    getCxf() {
+      const cxf = this.cxfProvider.get();
+      if (!cxf) {
+        throw new Error("CXF is not loaded");
+      }
+      return cxf;
+    }
+    setStore(store) {
+      this.storeProvider.set(store);
+    }
+    getStore() {
+      const store = this.storeProvider.get();
+      if (!store) {
+        throw new Error("Store is not initialized");
+      }
+      return store;
+    }
+    updateStore(data) {
+      const currentStore = this.getStore();
+      this.setStore({
+        ...currentStore,
+        ...data
+      });
+    }
+  };
+  var globalState = new GlobalState();
+
+  // src/handlers/cxfEventHandlers.ts
+  init_define_process();
+  var import_cxf_events = __toESM(require_typings());
+
+  // src/dialog.ts
+  init_define_process();
+  var createDialog = (url) => {
+    const config = globalState.getConfig();
+    const cxf = globalState.getCxf();
+    cxf.emit(config.CXF_DIALOG_OPEN, url);
+  };
+
+  // src/track.ts
+  init_define_process();
+  var trackOpenAction = (sid) => {
+    const config = globalState.getConfig();
+    const store = globalState.getStore();
+    const now = Date.now();
+    const parameters = getTokenAndLanguage(store);
+    const { zoneId } = parameters;
+    const sessionId = sid;
+    const { playerId, gameId, networkId, instanceId, sourceId } = store;
+    trackAction({
+      eventId: config.WEB_SHOP_CALL_TRACK_ID,
+      date: msToSec(now),
+      unixtimeMS: now,
+      sessionId,
+      zoneId: zoneId ? Number.parseInt(zoneId, 10) : void 0,
+      playerId: Number.parseInt(playerId, 10),
+      gameId: Number.parseInt(gameId, 10),
+      networkId: Number.parseInt(networkId, 10),
+      instanceId: Number.parseInt(instanceId, 10),
+      sourceId
+    });
+  };
+  var trackAction = (payload) => {
+    const config = globalState.getConfig();
+    const cxf = globalState.getCxf();
+    cxf.emit(config.CXF_TRACK_MSG, payload);
+  };
+
+  // src/types/index.ts
+  init_define_process();
+
+  // src/types/config.ts
+  init_define_process();
+
+  // src/whitelist.ts
+  init_define_process();
+  var whitelistedZones = /* @__PURE__ */ new Set([
+    // 264, Poland
+    316,
+    318,
+    460,
+    461,
+    767,
+    768,
+    802,
+    814,
+    830,
+    877
+  ]);
+
+  // src/handlers/pushHandlers.ts
+  init_define_process();
+  var onReward = (payload) => {
+    log("OnReward: payload", payload);
+    const { isCanvas } = globalState.getStore();
+    if (isCanvas) {
+      window.CanvasAgent?.instance?.hide();
+      window.CanvasAgent?.instance?.navigate();
+      return;
+    }
+    const url = createIframeUrl({
+      route: encodeURIComponent(payload.successUrl),
+      ...payload
+    });
+    globalState.updateStore({
+      lastPurchaseTab: payload.page,
+      sourceId: "successfulPayoutReward"
+    });
+    trackOpenAction(payload.sid);
+    createDialog(url);
+  };
+  var onLemonstandCategoryUpdate = ({ target, action, data }) => {
+    globalState.shopMessageBus.post({
+      eventName: "lemonstand.category.update" /* LEMONSTAND_CATEGORY_UPDATE */,
+      target,
+      data: { action, data }
+    });
+  };
+  var onLemonstandNotificationsCreated = ({ notifCount }) => {
+    log("onLemonstandNotificationsCreated -> notifCount:", notifCount);
+    const store = globalState.getStore();
+    if (notifCount > 0) {
+      const randomDelayMs = Math.floor(Math.random() * (Number(store.networkId) < 250 ? 12e4 : 15e3));
+      setTimeout(() => {
+        fetchUnreadOfferNotificationsCount();
+      }, randomDelayMs);
+    } else {
+      store.gameApi.invokeFn("setUnseenOffersCounter", 0).catch((error) => {
+        logError("setUnseenOffersCounter error:", error);
+      });
+    }
+  };
+  var createPushHandlers = () => {
+    return {
+      reward: onReward,
+      reward_received: onReward,
+      ["lemonstand.category.update" /* LEMONSTAND_CATEGORY_UPDATE */]: onLemonstandCategoryUpdate,
+      ["lemonstand.notifs.created" /* LEMONSTAND_NOTIFICATIONS_CREATED */]: onLemonstandNotificationsCreated
+    };
+  };
+
+  // src/handlers/cxfEventHandlers.ts
+  var isWindowMessageListenerAttached = false;
+  var eventListener = (event) => {
+    log(`Canvas event "${event.eventType}" received:`, event);
+    switch (event.eventType) {
+      case "native_catalog_request" /* NATIVE_CATALOG_REQUEST */: {
+        if (event?.paymentContractIds?.length > 0) {
+          if (!isWindowMessageListenerAttached) {
+            window.addEventListener("message", ({ data }) => {
+              if (data?.eventName === "lemonstand.category.update" /* LEMONSTAND_CATEGORY_UPDATE */ && data?.data?.action === "nativePriceUpdate") {
+                log(`${"lemonstand.category.update" /* LEMONSTAND_CATEGORY_UPDATE */} event`, data.data);
+                if (!data.data.data) return;
+                const nativeCatalog = {};
+                for (const key in data.data.data) {
+                  const { priceString, ...rest } = data.data.data[key];
+                  nativeCatalog[key] = rest;
+                }
+                log("nativeCatalog:", nativeCatalog);
+                window.CanvasAgent?.instance?.setNativeCatalog(nativeCatalog);
+              }
+            });
+            isWindowMessageListenerAttached = true;
+          }
+          const msg = transformPaymentContractIdsToNativePriceEvent(event.paymentContractIds);
+          window.postMessage(msg, "*");
+          log("Event `lemonstand.nativePrice` sent");
+        }
+        break;
+      }
+      case "native_checkout_request" /* NATIVE_CHECKOUT_REQUEST */: {
+        const { paymentContract, sessionId, collectionAlias, offerId } = event;
+        const { zoneId } = globalState.getStore();
+        window.postMessage(
+          {
+            eventName: "lemonstand.nativePay",
+            eventType: "bubble",
+            nativePayInfo: {
+              pkg: {
+                price: paymentContract?.price?.amount,
+                productIdMS: "",
+                productIds: { googleplay: paymentContract?.id },
+                tier: Number(paymentContract?.id?.split("_")?.at(-1))
+              },
+              // !sid || !type || !zoneId || !offerId || !successUrl || !criteria
+              meta: {
+                criteria: JSON.stringify({}),
+                lemonstand: true,
+                offerId,
+                sid: sessionId,
+                type: collectionAlias,
+                zoneId,
+                successUrl: window.location.href
+              }
+            }
+          },
+          "*"
+        );
+        log("Event `lemonstand.nativePay` sent");
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  };
+  var onOpen = (payload = {}) => {
+    log(import_cxf_events.CxfEvents.OpenIGS, "payload:", payload);
+    if (payload.sourceId) {
+      globalState.updateStore({
+        sourceId: payload.sourceId
+      });
+    }
+    const { isCanvas, lastPurchaseTab, gameApi } = globalState.getStore();
+    if (isCanvas) {
+      if (payload.page) {
+        window.CanvasAgent?.instance?.navigate(payload.page);
+      }
+      window.CanvasAgent?.instance?.show();
+      return;
+    }
+    const sid = createSessionId();
+    trackOpenAction(sid);
+    const url = createIframeUrl({
+      sid,
+      page: lastPurchaseTab,
+      ...payload
+    });
+    createDialog(url);
+    setTimeout(() => {
+      gameApi.invokeFn("setUnseenOffersCounter", 0);
+    }, 1e3);
+  };
+  var subscribeToCommonCxfEvents = (cxf) => {
+    const pushHandlers = createPushHandlers();
+    cxf.on(import_cxf_events.CxfEvents.OpenIGS, tryCatch(onOpen));
+    cxf.on(
+      import_cxf_events.CxfEvents.Push,
+      tryCatch(({ id, payload }) => {
+        log(import_cxf_events.CxfEvents.Push, id, payload);
+        const handler = pushHandlers[id];
+        handler && handler(payload);
+      })
+    );
+  };
+  var subscribeToGameEvents = (cxf) => {
+    cxf.on(import_cxf_events.CxfEvents.Login, (e) => {
+      const { gameEvents: eventsInLogin, language, token, zoneId } = e;
+      if (whitelistedZones.has(Number(zoneId)) && (Number(zoneId) > 300 || localStorage.getItem("cxf_canvas") === "enabled")) {
+        globalState.updateStore({
+          isCanvas: true
+        });
+      }
+      const { gameEvents, isCanvas } = globalState.getStore();
+      const eventNotExistPredicateGenerator = (existingEvents) => (event) => !existingEvents.map((event_) => event_.type).includes(event.type);
+      globalState.updateStore({
+        ...e,
+        gameEvents: [...gameEvents.filter(eventNotExistPredicateGenerator(eventsInLogin)), ...eventsInLogin]
+      });
+      log(import_cxf_events.CxfEvents.Login, globalState.getStore());
+      if (!isCanvas) {
+        globalState.fetchUnreadOfferNotificationsCount();
+        return;
+      }
+      if (typeof window.CanvasAgent?.create === "function") {
+        const { CANVAS_APP_ID_BY_GAME } = globalState.getConfig();
+        const platform = detectPlatform();
+        const canvasApps = CANVAS_APP_ID_BY_GAME[cxf.gameId];
+        const canvasAppId = typeof canvasApps === "string" ? canvasApps : canvasApps?.[platform];
+        window.CanvasAgent.create({
+          authClientId: "lemonstand",
+          canvasAppId,
+          eventListener,
+          locale: language,
+          token
+        }).then((res) => {
+          window.CanvasAgent.instance = res;
+          log(import_cxf_events.CxfEvents.Login, "Canvas created");
+        }).catch((error) => {
+          logError("Cannot create instance of Canvas", error);
+        });
+      }
+    });
+    cxf.on(import_cxf_events.CxfEvents.GameEventUpdate, (e) => {
+      log(import_cxf_events.CxfEvents.GameEventUpdate, e);
+      const { gameEvents, isCanvas } = globalState.getStore();
+      const updatedEventTypes = new Set(e.map((event) => event.type));
+      globalState.updateStore({
+        gameEvents: [...gameEvents.filter((event) => !updatedEventTypes.has(event.type)), ...e]
+      });
+      if (isCanvas) {
+        window.CanvasAgent?.instance?.refresh();
+      }
+      log(import_cxf_events.CxfEvents.GameEventUpdate, "reducer", globalState.getStore());
+    });
+    cxf.on(import_cxf_events.CxfEvents.GameEventAdd, (e) => {
+      log(import_cxf_events.CxfEvents.GameEventAdd, e);
+      const { gameEvents, isCanvas } = globalState.getStore();
+      globalState.updateStore({
+        gameEvents: [...gameEvents, e]
+      });
+      if (isCanvas) {
+        window.CanvasAgent?.instance?.refresh();
+      }
+      log(import_cxf_events.CxfEvents.GameEventAdd, "reducer", globalState.getStore());
+    });
+    cxf.on(import_cxf_events.CxfEvents.GameEventRemove, (e) => {
+      log(import_cxf_events.CxfEvents.GameEventRemove, e);
+      const { gameEvents, isCanvas } = globalState.getStore();
+      globalState.updateStore({
+        gameEvents: gameEvents.filter(({ type }) => type !== e)
+      });
+      if (isCanvas) {
+        window.CanvasAgent?.instance?.refresh();
+      }
+      log(import_cxf_events.CxfEvents.GameEventRemove, "reducer", globalState.getStore());
+    });
+    cxf.on(import_cxf_events.CxfEvents.LevelChanged, (level) => {
+      log(import_cxf_events.CxfEvents.LevelChanged, level);
+      const { isCanvas } = globalState.getStore();
+      globalState.updateStore({
+        level
+      });
+      log(import_cxf_events.CxfEvents.LevelChanged, "reducer", globalState.getStore());
+      if (isCanvas) {
+        window.CanvasAgent?.instance?.refresh();
+      } else {
+        globalState.fetchUnreadOfferNotificationsCount();
+      }
+    });
+    cxf.on(import_cxf_events.CxfEvents.LegendLevelChanged, (legendLevel) => {
+      log(import_cxf_events.CxfEvents.LegendLevelChanged, `legendLevel: ${legendLevel}`);
+      globalState.updateStore({
+        legendLevel
+      });
+      const store = globalState.getStore();
+      log(import_cxf_events.CxfEvents.LegendLevelChanged, "reducer", store);
+      globalState.fetchUnreadOfferNotificationsCount();
+    });
+  };
+  var subscribeToNativeSubscriptionEnable = (cxf) => {
+    cxf.on("cxf.native.subscription.enable" /* CXF_NATIVE_SUBSCRIPTION_ENABLE */, (enabled) => {
+      globalState.updateStore({
+        subscriptionDisabled: enabled === 0,
+        customizationSuffix: enabled === 0 ? "no-subscription" : ""
+      });
+      globalState.preResolveConfig();
+    });
+  };
+  var subscribeToCustomizationSuffix = (cxf) => {
+    cxf.on("cxf.set.customization.surfix" /* CXF_SET_CUSTOMIZATION_SUFFIX */, (suffix) => {
+      const { customizationSuffix } = globalState.getStore();
+      if (suffix === customizationSuffix) {
+        return;
+      }
+      globalState.updateStore({
+        customizationSuffix: suffix || ""
+      });
+      globalState.preResolveConfig();
+    });
+  };
+  var subscribeToAdStatus = (cxf) => {
+    const config = globalState.getConfig();
+    cxf.on(config.CXF_AD_STATUS, ({ areBannersAvailable, bannersDetails }) => {
+      globalState.updateStore({
+        adStatus: {
+          areBannersAvailable,
+          bannersDetails
+        }
+      });
+    });
+  };
+  var subscribeToTempServerContext = (cxf) => {
+    cxf.on("cxf.join.temp.server" /* CXF_JOIN_TEMP_SERVER */, (isTemp) => {
+      const store = globalState.getStore();
+      globalState.updateStore({
+        isTempServer: Boolean(isTemp)
+      });
+      if (store.customizationSuffix === "" || store.customizationSuffix === "temp") {
+        globalState.updateStore({
+          customizationSuffix: isTemp ? "temp" : ""
+        });
+        globalState.preResolveConfig();
+      }
+    });
+  };
+  var createCxfEventHandlers = () => {
+    return [
+      subscribeToCommonCxfEvents,
+      subscribeToGameEvents,
+      subscribeToAdStatus,
+      subscribeToTempServerContext,
+      subscribeToNativeSubscriptionEnable,
+      subscribeToCustomizationSuffix
+    ];
+  };
+
+  // src/handlers/postMessageHandlers.ts
+  init_define_process();
+  var onSalesPageOpen = () => {
+    log("OnOpenSalesOffersPage");
+    const { isCanvas } = globalState.getStore();
+    if (isCanvas) {
+      window.CanvasAgent?.instance?.navigate("supersale");
+      return;
+    }
+    const sid = createSessionId();
+    const url = createIframeUrl({
+      page: "sale-offers",
+      sid
+    });
+    createDialog(url);
+  };
+  var onLemonstandClose = () => {
+    const store = globalState.getStore();
+    log("onLemonstandClose", store);
+    fetchUnreadOfferNotificationsCount();
+  };
+  var createPostMessageHandlers = () => {
+    return {
+      ["cxf.webshop.sales.open" /* CXF_OPEN_SALES_MSG */]: onSalesPageOpen,
+      ["cxf.dialog.close" /* CXF_DIALOG_CLOSE */]: onLemonstandClose
+    };
+  };
+
+  // src/app.ts
+  var app = (cxf) => {
+    const postMessageHandlers = createPostMessageHandlers();
+    const subscribeCxf = createCxfEventHandlers();
+    window.addEventListener(
+      "message",
+      tryCatch(({ data }) => {
+        if (data) {
+          const handler = postMessageHandlers[data.name];
+          if (handler) {
+            log("POST MESSAGE", data);
+            handler(data.payload);
+          }
+        }
+      })
+    );
+    for (const handler of subscribeCxf) {
+      handler(cxf);
+    }
+    globalState.preResolveConfig();
+    log("App has started");
+  };
+
+  // src/config.ts
+  init_define_process();
+  var import_cxf_events2 = __toESM(require_typings());
+  var COMMON_CONFIG = {
+    CANVAS_AGENT_URL: define_process_default.env.CANVAS_AGENT_URL,
+    CANVAS_APP_ID_BY_GAME: define_process_default.env.CANVAS_APP_ID_BY_GAME,
+    CUSTOMIZATION_URL: define_process_default.env.CUSTOMIZATION_URL,
+    CUSTOMIZATION_URL_TEMPLATE: define_process_default.env.CUSTOMIZATION_URL_TEMPLATE,
+    BASE_URL: define_process_default.env.BASE_URL,
+    CXF_DIALOG_OPEN: "cxf.dialog.open",
+    CXF_DIALOG_CLOSE: "cxf.dialog.close",
+    CXF_TRACK_MSG: "cxf.tracking.message",
+    CXF_BTN_CLICK_MSG: import_cxf_events2.CxfEvents.OpenIGS,
+    CXF_OPEN_SALES_MSG: "cxf.webshop.sales.open" /* CXF_OPEN_SALES_MSG */,
+    WEB_SHOP_CALL_TRACK_ID: 1181,
+    CXF_ERROR: "cxf.error",
+    CXF_PUSH: "cxf.push",
+    CXF_AD_STATUS: "cxf.adBanner.status"
+  };
+  var GAME_SPECIFIC_CONFIG = {
+    12: {
+      LEGEND_LEVEL_IS_USED: true
+    },
+    15: {
+      LEGEND_LEVEL_IS_USED: false
+    },
+    16: {
+      LEGEND_LEVEL_IS_USED: true
+    }
+  };
+  var createConfig = (gameId) => {
+    return {
+      ...COMMON_CONFIG,
+      ...GAME_SPECIFIC_CONFIG[gameId]
+    };
+  };
+
+  // src/index.ts
+  require_dist().then((cxf) => {
+    const config = createConfig(cxf.gameId);
+    globalState.setConfig(config);
+    globalState.setCxf(cxf);
+    const store = initializeStore(cxf);
+    globalState.setStore(store);
+    loadScript(config.CANVAS_AGENT_URL).then(() => {
+      log(`Canvas agent loaded: ${config.CANVAS_AGENT_URL}`);
+    }).catch((error) => {
+      logError("Canvas agent load error", error);
+    });
+    app(cxf);
+  });
+})();
+//# sourceMappingURL=webshop-cxf.js.map