@pack/hydrogen 2.0.0-beta.2 → 2.0.1

package/dist/index.js

@@ -4,9 +4,16 @@ 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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/ua-parser-js/src/ua-parser.js
 var require_ua_parser = __commonJS({
@@ -1309,15 +1317,15 @@ var require_ua_parser = __commonJS({
   }
 });
 
-// ../../node_modules/cookie/index.js
+// node_modules/cookie/index.js
 var require_cookie = __commonJS({
-  "../../node_modules/cookie/index.js"(exports) {
+  "node_modules/cookie/index.js"(exports) {
     "use strict";
-    exports.parse = parse;
-    exports.serialize = serialize;
+    exports.parse = parse2;
+    exports.serialize = serialize2;
     var __toString = Object.prototype.toString;
     var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-    function parse(str, options) {
+    function parse2(str, options) {
       if (typeof str !== "string") {
         throw new TypeError("argument str must be a string");
       }
@@ -1349,7 +1357,7 @@ var require_cookie = __commonJS({
       }
       return obj;
     }
-    function serialize(name, val, options) {
+    function serialize2(name, val, options) {
       var opt = options || {};
       var enc = opt.encode || encode;
       if (typeof enc !== "function") {
@@ -1454,147 +1462,3020 @@ var require_cookie = __commonJS({
   }
 });
 
-// ../packlytics/dist/utils/get-packlytics-id.js
-function sha256(ascii) {
-  function rightRotate(value, amount) {
-    return value >>> amount | value << 32 - amount;
-  }
-  const mathPow = Math.pow;
-  const maxWord = mathPow(2, 32);
-  const lengthProperty = "length";
-  let i, j;
-  let result = "";
-  const words = [];
-  const asciiBitLength = ascii[lengthProperty] * 8;
-  let hash = sha256.h = sha256.h || [];
-  const k = sha256.k = sha256.k || [];
-  let primeCounter = k[lengthProperty];
-  const isComposite = {};
-  for (let candidate = 2; primeCounter < 64; candidate++) {
-    if (!isComposite[candidate]) {
-      for (i = 0; i < 313; i += candidate) {
-        isComposite[i] = candidate;
+// ../../node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    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 parse2(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
       }
-      hash[primeCounter] = mathPow(candidate, 0.5) * maxWord | 0;
-      k[primeCounter++] = mathPow(candidate, 1 / 3) * maxWord | 0;
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse2(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" : "");
     }
   }
-  ascii += "\x80";
-  while (ascii[lengthProperty] % 64 - 56)
-    ascii += "\0";
-  for (i = 0; i < ascii[lengthProperty]; i++) {
-    j = ascii.charCodeAt(i);
-    if (j >> 8)
-      return;
-    words[i >> 2] |= j << (3 - i) % 4 * 8;
+});
+
+// ../../node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug5.debug = createDebug5;
+      createDebug5.default = createDebug5;
+      createDebug5.coerce = coerce;
+      createDebug5.disable = disable;
+      createDebug5.enable = enable;
+      createDebug5.enabled = enabled;
+      createDebug5.humanize = require_ms();
+      createDebug5.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug5[key] = env[key];
+      });
+      createDebug5.names = [];
+      createDebug5.skips = [];
+      createDebug5.formatters = {};
+      function selectColor(namespace) {
+        let hash2 = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
+          hash2 |= 0;
+        }
+        return createDebug5.colors[Math.abs(hash2) % createDebug5.colors.length];
+      }
+      createDebug5.selectColor = selectColor;
+      function createDebug5(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug5(...args) {
+          if (!debug5.enabled) {
+            return;
+          }
+          const self2 = debug5;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug5.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 = createDebug5.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self2, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug5.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug5.log;
+          logFn.apply(self2, args);
+        }
+        debug5.namespace = namespace;
+        debug5.useColors = createDebug5.useColors();
+        debug5.color = createDebug5.selectColor(namespace);
+        debug5.extend = extend;
+        debug5.destroy = createDebug5.destroy;
+        Object.defineProperty(debug5, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug5.namespaces) {
+              namespacesCache = createDebug5.namespaces;
+              enabledCache = createDebug5.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug5.init === "function") {
+          createDebug5.init(debug5);
+        }
+        return debug5;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug5(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug5.save(namespaces);
+        createDebug5.namespaces = namespaces;
+        createDebug5.names = [];
+        createDebug5.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug5.skips.push(ns.slice(1));
+          } else {
+            createDebug5.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 = [
+          ...createDebug5.names,
+          ...createDebug5.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug5.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug5.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug5.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`.");
+      }
+      createDebug5.enable(createDebug5.load());
+      return createDebug5;
+    }
+    module.exports = setup;
   }
-  words[words[lengthProperty]] = asciiBitLength / maxWord | 0;
-  words[words[lengthProperty]] = asciiBitLength;
-  for (j = 0; j < words[lengthProperty]; ) {
-    const w = words.slice(j, j += 16);
-    const oldHash = hash;
-    hash = hash.slice(0, 8);
-    for (i = 0; i < 64; i++) {
-      const i2 = i + j;
-      const w15 = w[i - 15], w2 = w[i - 2];
-      const a = hash[0], e = hash[4];
-      const temp1 = hash[7] + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) + // S1
-      (e & hash[5] ^ ~e & hash[6]) + // ch
-      k[i] + // Expand the message schedule if needed
-      (w[i] = i < 16 ? w[i] : w[i - 16] + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ w15 >>> 3) + // s0
-      w[i - 7] + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ w2 >>> 10) | // s1
-      0);
-      const temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) + // S0
-      (a & hash[1] ^ a & hash[2] ^ hash[1] & hash[2]);
-      hash = [temp1 + temp2 | 0].concat(hash);
-      hash[4] = hash[4] + temp1 | 0;
+});
+
+// ../../node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    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+)/);
     }
-    for (i = 0; i < 8; i++) {
-      hash[i] = hash[i] + oldHash[i] | 0;
+    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 process !== "undefined" && "env" in process) {
+        r = process.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;
+      }
+    };
   }
-  for (i = 0; i < 8; i++) {
-    for (j = 3; j + 1; j--) {
-      const b = hash[i] >> j * 8 & 255;
-      result += (b < 16 ? 0 : "") + b.toString(16);
+});
+
+// ../../node_modules/curriable/dist/curriable.js
+var require_curriable = __commonJS({
+  "../../node_modules/curriable/dist/curriable.js"(exports, module) {
+    "use strict";
+    (function(global, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = global || self, factory(global.curriable = {}));
+    })(exports, function(exports2) {
+      "use strict";
+      var __ = typeof Symbol === "function" ? Symbol("curriable placeholder") : 60881;
+      function getCurried(fn, arity) {
+        function _curried(args) {
+          return function() {
+            var length = args.length;
+            var newArgs = arguments;
+            var newArgsLength = newArgs.length;
+            var combined = [];
+            var newArgsIndex = 0;
+            var remaining = arity;
+            var value;
+            if (length) {
+              var index = -1;
+              while (++index < length) {
+                combined[index] = value = args[index] === __ && newArgsIndex < newArgsLength ? newArgs[newArgsIndex++] : args[index];
+                if (value !== __) {
+                  --remaining;
+                }
+              }
+            }
+            if (newArgsIndex < newArgsLength) {
+              while (newArgsIndex < newArgsLength) {
+                combined[combined.length] = value = newArgs[newArgsIndex];
+                if (value !== __ && newArgsIndex < arity) {
+                  --remaining;
+                }
+                ++newArgsIndex;
+              }
+            }
+            return remaining > 0 ? _curried(combined) : fn.apply(this, combined);
+          };
+        }
+        return _curried([]);
+      }
+      function curry2(fn, arityOverride) {
+        var arity = typeof arityOverride === "number" ? arityOverride : fn.length;
+        var curried = getCurried(fn, arity);
+        curried.arity = arity;
+        curried.fn = fn;
+        return curried;
+      }
+      curry2.__ = __;
+      function isPlaceholder(value) {
+        return value === __;
+      }
+      curry2.isPlaceholder = isPlaceholder;
+      function uncurry(curried) {
+        return curried.fn;
+      }
+      curry2.uncurry = uncurry;
+      exports2.__ = __;
+      exports2.curry = curry2;
+      exports2.default = curry2;
+      exports2.isPlaceholder = isPlaceholder;
+      exports2.uncurry = uncurry;
+      Object.defineProperty(exports2, "__esModule", { value: true });
+    });
+  }
+});
+
+// ../../node_modules/hash-it/es/constants.js
+var _SELF_TAGS, _TOSTRING_TAGS, _TYPEDARRAY_TAGS, _UNPARSEABLE_TAGS, HAS_BUFFER_FROM_SUPPORT, HAS_UINT16ARRAY_SUPPORT, HTML_ELEMENT_REGEXP, SVG_ELEMENT_REGEXP, OBJECT_CLASSES, OBJECT_CLASS_MAP, OBJECT_CLASS_TYPE_MAP, ITERABLE_TAGS, PRIMITIVE_TAGS, SELF_TAGS, TOSTRING_TAGS, TYPEDARRAY_TAGS, UNPARSEABLE_TAGS;
+var init_constants = __esm({
+  "../../node_modules/hash-it/es/constants.js"() {
+    "use strict";
+    HAS_BUFFER_FROM_SUPPORT = typeof Buffer !== "undefined" && typeof Buffer.from === "function";
+    HAS_UINT16ARRAY_SUPPORT = typeof Uint16Array === "function";
+    HTML_ELEMENT_REGEXP = /\[object (HTML(.*)Element)\]/;
+    SVG_ELEMENT_REGEXP = /\[object (SVG(.*)Element)\]/;
+    OBJECT_CLASSES = ["Arguments", "Array", "ArrayBuffer", "Boolean", "DataView", "Date", "DocumentFragment", "Error", "Event", "Float32Array", "Float64Array", "Function", "Generator", "GeneratorFunction", "HTMLElement", "Int8Array", "Int16Array", "Int32Array", "Map", "Null", "Number", "Object", "Promise", "RegExp", "Set", "String", "Symbol", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "Undefined", "WeakMap", "WeakSet", "Window"];
+    OBJECT_CLASS_MAP = OBJECT_CLASSES.reduce(function(objectClasses, type) {
+      objectClasses["[object " + type + "]"] = type;
+      return objectClasses;
+    }, {});
+    OBJECT_CLASS_TYPE_MAP = Object.keys(OBJECT_CLASS_MAP).reduce(function(objectClassTypes, objectClass) {
+      objectClassTypes[OBJECT_CLASS_MAP[objectClass].toUpperCase()] = objectClass;
+      return objectClassTypes;
+    }, {});
+    ITERABLE_TAGS = {
+      "[object Map]": true,
+      "[object Set]": true
+    };
+    PRIMITIVE_TAGS = {
+      boolean: true,
+      function: true,
+      number: true,
+      string: true,
+      undefined: true
+    };
+    SELF_TAGS = (_SELF_TAGS = {}, _SELF_TAGS[OBJECT_CLASS_TYPE_MAP.ARGUMENTS] = true, _SELF_TAGS[OBJECT_CLASS_TYPE_MAP.ARRAY] = true, _SELF_TAGS);
+    TOSTRING_TAGS = (_TOSTRING_TAGS = {}, _TOSTRING_TAGS[OBJECT_CLASS_TYPE_MAP.REGEXP] = true, _TOSTRING_TAGS[OBJECT_CLASS_TYPE_MAP.SYMBOL] = true, _TOSTRING_TAGS);
+    TYPEDARRAY_TAGS = (_TYPEDARRAY_TAGS = {}, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.FLOAT32ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.FLOAT64ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.INT8ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.INT16ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.INT32ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.UINT8ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.UINT8CLAMPEDARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.UINT16ARRAY] = true, _TYPEDARRAY_TAGS[OBJECT_CLASS_TYPE_MAP.UINT32ARRAY] = true, _TYPEDARRAY_TAGS);
+    UNPARSEABLE_TAGS = (_UNPARSEABLE_TAGS = {}, _UNPARSEABLE_TAGS[OBJECT_CLASS_TYPE_MAP.GENERATOR] = true, _UNPARSEABLE_TAGS[OBJECT_CLASS_TYPE_MAP.PROMISE] = true, _UNPARSEABLE_TAGS[OBJECT_CLASS_TYPE_MAP.WEAKMAP] = true, _UNPARSEABLE_TAGS[OBJECT_CLASS_TYPE_MAP.WEAKSET] = true, _UNPARSEABLE_TAGS);
+  }
+});
+
+// ../../node_modules/hash-it/es/utils.js
+function getFunctionName(fn) {
+  return fn.name || (fn.toString().match(FUNCTION_NAME_REGEX) || [])[1] || "anonymous";
+}
+function getIntegerHashValue(string) {
+  var index = string.length, hashA = 5381, hashB = 52711, charCode;
+  while (index--) {
+    charCode = string.charCodeAt(index);
+    hashA = hashA * 33 ^ charCode;
+    hashB = hashB * 33 ^ charCode;
+  }
+  return (hashA >>> 0) * 4096 + (hashB >>> 0);
+}
+function getSortedEvent(event) {
+  return {
+    bubbles: event.bubbles,
+    cancelBubble: event.cancelBubble,
+    cancelable: event.cancelable,
+    composed: event.composed,
+    currentTarget: event.currentTarget,
+    defaultPrevented: event.defaultPrevented,
+    eventPhase: event.eventPhase,
+    isTrusted: event.isTrusted,
+    returnValue: event.returnValue,
+    target: event.target,
+    type: event.type
+  };
+}
+function shouldSort(valueA, valueB) {
+  return valueA > valueB;
+}
+function shouldSortPair(pairA, pairB) {
+  return pairA[0] > pairB[0];
+}
+function sort(array, fn) {
+  var subIndex, value;
+  for (var index = 0; index < array.length; ++index) {
+    value = array[index];
+    for (subIndex = index - 1; ~subIndex && fn(array[subIndex], value); --subIndex) {
+      array[subIndex + 1] = array[subIndex];
     }
+    array[subIndex + 1] = value;
   }
-  return result;
+  return array;
 }
-function createHash(data) {
-  const hash = sha256(data);
-  return [
-    hash?.substring(0, 8),
-    hash?.substring(8, 12),
-    hash?.substring(12, 16),
-    hash?.substring(16, 20),
-    hash?.substring(20, 32)
-  ].join("-");
+function getSortedIterable(iterable, cache, keys2) {
+  var isMap = typeof iterable.get === "function";
+  var entries = [];
+  if (isMap) {
+    iterable.forEach(function(value, key) {
+      entries.push([
+        // eslint-disable-next-line no-use-before-define
+        stringify(key, cache, keys2),
+        // eslint-disable-next-line no-use-before-define
+        stringify(value, cache, keys2)
+      ]);
+    });
+    sort(entries, shouldSortPair);
+  } else {
+    iterable.forEach(function(value) {
+      entries.push(stringify(value, cache, keys2));
+    });
+    sort(entries, shouldSort);
+  }
+  var _final = getFunctionName(iterable.constructor) + "|[";
+  for (var index = 0, length = entries.length, entry; index < length; ++index) {
+    entry = entries[index];
+    _final += (index ? "," : "") + (isMap ? "[" + entry[0] + "," + entry[1] + "]" : entry);
+  }
+  return _final + "]";
 }
-function getPacklyticsId(data, secret) {
-  const currentDate = /* @__PURE__ */ new Date();
-  const formattedDate = currentDate.toLocaleDateString("en-US");
-  const salt = sha256(formattedDate + secret);
-  return createHash(data + salt);
+function getSortedObject(object) {
+  var objectKeys = sort(keys(object), shouldSort);
+  var newObject = {};
+  var key;
+  for (var index = 0; index < objectKeys.length; ++index) {
+    key = objectKeys[index];
+    newObject[key] = object[key];
+  }
+  return newObject;
 }
-
-// ../../node_modules/intl-parse-accept-language/dist/intl-parse-accept-language.esm.js
-var defaultValidate = function defaultValidate2(locale) {
-  return locale;
-};
-var parseAcceptLanguage = function parseAcceptLanguage2(languageHeaderValue, options) {
-  if (options === void 0) {
-    options = {};
+function getStringifiedArrayBufferFallback(buffer) {
+  return String.fromCharCode.apply(null, new Uint16Array(buffer));
+}
+function getStringifiedArrayBufferModern(buffer) {
+  return Buffer.from(buffer).toString("utf8");
+}
+function getStringifiedArrayBufferNoSupport() {
+  return "";
+}
+function getStringifiedDocumentFragment(fragment) {
+  var children = fragment.children;
+  var innerHTML = "";
+  for (var index = 0; index < children.length; ++index) {
+    innerHTML += children[index].outerHTML;
   }
-  if (!languageHeaderValue) return [];
-  var _options = options, _options$ignoreWildca = _options.ignoreWildcard, ignoreWildcard = _options$ignoreWildca === void 0 ? true : _options$ignoreWildca, _options$validate = _options.validate, validate = _options$validate === void 0 ? defaultValidate : _options$validate;
-  return languageHeaderValue.split(",").map(function(lang) {
-    var _lang$split = lang.split(";"), locale = _lang$split[0], _lang$split$ = _lang$split[1], q = _lang$split$ === void 0 ? "q=1" : _lang$split$;
-    var trimmedLocale = locale.trim();
-    var numQ = Number(q.replace(/q ?=/, ""));
-    if (isNaN(numQ)) return [0, trimmedLocale];
-    return [numQ, trimmedLocale];
-  }).sort(function(_ref, _ref2) {
-    var q1 = _ref[0];
-    var q2 = _ref2[0];
-    return q2 - q1;
-  }).flatMap(function(_ref3) {
-    var locale = _ref3[1];
-    if (locale === "*" && ignoreWildcard) return [];
-    try {
-      return validate(locale) || [];
-    } catch (_unused) {
-      return [];
+  return innerHTML;
+}
+function getCutoffIndex(array, value) {
+  for (var index = 0; index < array.length; ++index) {
+    if (array[index] === value) {
+      return index + 1;
     }
-  });
-};
-
-// ../packlytics/dist/utils/get-headers.js
-function getHeaders(requestOrHeaders) {
-  if (requestOrHeaders instanceof Request) {
-    return requestOrHeaders.headers;
   }
-  return requestOrHeaders;
+  return 0;
 }
-
-// ../packlytics/dist/utils/get-client-locales.js
-function getClientLocales(requestOrHeaders) {
-  let headers = getHeaders(requestOrHeaders);
-  let acceptLanguage = headers.get("Accept-Language");
-  if (!acceptLanguage)
-    return void 0;
-  let locales = parseAcceptLanguage(acceptLanguage, {
-    validate: Intl.DateTimeFormat.supportedLocalesOf,
-    ignoreWildcard: true
-  });
-  if (locales.length === 0)
-    return void 0;
-  return locales;
+function getNormalizedValue(value, cache, keys2, passedTag) {
+  if (passedTag === void 0) {
+    var type = typeof value;
+    if (type === "string" || PRIMITIVE_TAGS[type]) {
+      return type + "|" + value;
+    }
+    if (value === null) {
+      return "null|" + value;
+    }
+  }
+  var tag = passedTag || toString.call(value);
+  if (SELF_TAGS[tag]) {
+    return value;
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.OBJECT) {
+    return getSortedObject(value);
+  }
+  if (TOSTRING_TAGS[tag]) {
+    return OBJECT_CLASS_MAP[tag] + "|" + value.toString();
+  }
+  if (ITERABLE_TAGS[tag]) {
+    return getSortedIterable(value, cache, keys2);
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.DATE) {
+    return OBJECT_CLASS_MAP[tag] + "|" + value.getTime();
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.ERROR) {
+    return OBJECT_CLASS_MAP[tag] + "|" + value.stack;
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.EVENT) {
+    return getSortedEvent(value);
+  }
+  if (UNPARSEABLE_TAGS[tag]) {
+    return OBJECT_CLASS_MAP[tag] + "|NOT_ENUMERABLE";
+  }
+  if (HTML_ELEMENT_REGEXP.test(tag) || SVG_ELEMENT_REGEXP.test(tag)) {
+    return tag.slice(8, -1) + "|" + value.outerHTML;
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.DOCUMENTFRAGMENT) {
+    return OBJECT_CLASS_MAP[tag] + "|" + getStringifiedDocumentFragment(value);
+  }
+  if (TYPEDARRAY_TAGS[tag]) {
+    return OBJECT_CLASS_MAP[tag] + "|" + value.join(",");
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.ARRAYBUFFER) {
+    return OBJECT_CLASS_MAP[tag] + "|" + getStringifiedArrayBuffer(value);
+  }
+  if (tag === OBJECT_CLASS_TYPE_MAP.DATAVIEW) {
+    return OBJECT_CLASS_MAP[tag] + "|" + getStringifiedArrayBuffer(value.buffer);
+  }
+  return value;
 }
-
-// ../packlytics/dist/utils/sanatize-payload.js
-var sanitizePayload = (data) => {
-  let dataStr = JSON.stringify(data);
+function createReplacer(cache, keys2) {
+  if (cache === void 0) {
+    cache = [];
+  }
+  if (keys2 === void 0) {
+    keys2 = [];
+  }
+  return function(key, value) {
+    if (typeof value === "object") {
+      if (cache.length) {
+        var thisCutoff = getCutoffIndex(cache, this);
+        if (thisCutoff === 0) {
+          cache.push(this);
+        } else {
+          cache.splice(thisCutoff);
+          keys2.splice(thisCutoff);
+        }
+        keys2.push(key);
+        var valueCutoff = getCutoffIndex(cache, value);
+        if (valueCutoff !== 0) {
+          return "[~" + (keys2.slice(0, valueCutoff).join(".") || ".") + "]";
+        }
+        cache.push(value);
+      } else {
+        cache[0] = value;
+        keys2[0] = key;
+      }
+    }
+    if (key && this[key] instanceof Date) {
+      return getNormalizedValue(this[key], cache, keys2, OBJECT_CLASS_TYPE_MAP.DATE, cache, keys2);
+    }
+    return getNormalizedValue(value, cache, keys2);
+  };
+}
+function stringify(value, cache, keys2) {
+  if (!value || typeof value !== "object") {
+    return getNormalizedValue(value, cache, keys2);
+  }
+  var tag = toString.call(value);
+  if (tag === OBJECT_CLASS_TYPE_MAP.DATE || tag === OBJECT_CLASS_TYPE_MAP.REGEXP) {
+    return getNormalizedValue(value, cache, keys2, tag);
+  }
+  return JSON.stringify(value, createReplacer(cache, keys2));
+}
+var FUNCTION_NAME_REGEX, toString, keys, getStringifiedArrayBuffer;
+var init_utils = __esm({
+  "../../node_modules/hash-it/es/utils.js"() {
+    "use strict";
+    init_constants();
+    FUNCTION_NAME_REGEX = /^\s*function\s*([^(]*)/i;
+    toString = Object.prototype.toString;
+    keys = Object.keys;
+    getStringifiedArrayBuffer = function() {
+      if (HAS_BUFFER_FROM_SUPPORT) {
+        return getStringifiedArrayBufferModern;
+      }
+      if (HAS_UINT16ARRAY_SUPPORT) {
+        return getStringifiedArrayBufferFallback;
+      }
+      return getStringifiedArrayBufferNoSupport;
+    }();
+  }
+});
+
+// ../../node_modules/hash-it/es/index.js
+var es_exports = {};
+__export(es_exports, {
+  default: () => es_default,
+  hash: () => hash
+});
+function hash(value) {
+  return getIntegerHashValue(stringify(value));
+}
+var import_curriable, es_default;
+var init_es = __esm({
+  "../../node_modules/hash-it/es/index.js"() {
+    "use strict";
+    import_curriable = __toESM(require_curriable());
+    init_utils();
+    hash.is = (0, import_curriable.curry)(function(object, otherObject) {
+      return hash(object) === hash(otherObject);
+    });
+    hash.is.all = (0, import_curriable.curry)(function(objectBasis) {
+      var isEqual = hash.is(objectBasis);
+      for (var index = 1; index < arguments.length; ++index) {
+        if (!isEqual(arguments[index])) {
+          return false;
+        }
+      }
+      return true;
+    }, 2);
+    hash.is.any = (0, import_curriable.curry)(function(objectBasis) {
+      var isEqual = hash.is(objectBasis);
+      for (var index = 1; index < arguments.length; index++) {
+        if (isEqual(arguments[index])) {
+          return true;
+        }
+      }
+      return false;
+    }, 2);
+    hash.is.not = (0, import_curriable.curry)(function(object, otherObject) {
+      return hash(object) !== hash(otherObject);
+    });
+    es_default = hash;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/fact.js
+var require_fact = __commonJS({
+  "../../node_modules/json-rules-engine/dist/fact.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _hashIt = (init_es(), __toCommonJS(es_exports));
+    var _hashIt2 = _interopRequireDefault(_hashIt);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var Fact = function() {
+      function Fact2(id, valueOrMethod, options) {
+        _classCallCheck(this, Fact2);
+        this.id = id;
+        var defaultOptions = { cache: true };
+        if (typeof options === "undefined") {
+          options = defaultOptions;
+        }
+        if (typeof valueOrMethod !== "function") {
+          this.value = valueOrMethod;
+          this.type = this.constructor.CONSTANT;
+        } else {
+          this.calculationMethod = valueOrMethod;
+          this.type = this.constructor.DYNAMIC;
+        }
+        if (!this.id) throw new Error("factId required");
+        if (typeof this.value === "undefined" && typeof this.calculationMethod === "undefined") {
+          throw new Error("facts must have a value or method");
+        }
+        this.priority = parseInt(options.priority || 1, 10);
+        this.options = Object.assign({}, defaultOptions, options);
+        this.cacheKeyMethod = this.defaultCacheKeys;
+        return this;
+      }
+      _createClass(Fact2, [{
+        key: "isConstant",
+        value: function isConstant() {
+          return this.type === this.constructor.CONSTANT;
+        }
+      }, {
+        key: "isDynamic",
+        value: function isDynamic() {
+          return this.type === this.constructor.DYNAMIC;
+        }
+        /**
+         * Return the fact value, based on provided parameters
+         * @param  {object} params
+         * @param  {Almanac} almanac
+         * @return {any} calculation method results
+         */
+      }, {
+        key: "calculate",
+        value: function calculate(params, almanac) {
+          if (this.hasOwnProperty("value")) {
+            return this.value;
+          }
+          return this.calculationMethod(params, almanac);
+        }
+        /**
+         * Return a cache key (MD5 string) based on parameters
+         * @param  {object} obj - properties to generate a hash key from
+         * @return {string} MD5 string based on the hash'd object
+         */
+      }, {
+        key: "defaultCacheKeys",
+        /**
+         * Default properties to use when caching a fact
+         * Assumes every fact is a pure function, whose computed value will only
+         * change when input params are modified
+         * @param  {string} id - fact unique identifer
+         * @param  {object} params - parameters passed to fact calcution method
+         * @return {object} id + params
+         */
+        value: function defaultCacheKeys(id, params) {
+          return { params, id };
+        }
+        /**
+         * Generates the fact's cache key(MD5 string)
+         * Returns nothing if the fact's caching has been disabled
+         * @param  {object} params - parameters that would be passed to the computation method
+         * @return {string} cache key
+         */
+      }, {
+        key: "getCacheKey",
+        value: function getCacheKey2(params) {
+          if (this.options.cache === true) {
+            var cacheProperties = this.cacheKeyMethod(this.id, params);
+            var _hash = Fact2.hashFromObject(cacheProperties);
+            return _hash;
+          }
+        }
+      }], [{
+        key: "hashFromObject",
+        value: function hashFromObject(obj) {
+          return (0, _hashIt2.default)(obj);
+        }
+      }]);
+      return Fact2;
+    }();
+    Fact.CONSTANT = "CONSTANT";
+    Fact.DYNAMIC = "DYNAMIC";
+    exports.default = Fact;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/json-rules-engine/dist/debug.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = debug5;
+    function debug5(message) {
+      if (typeof process !== "undefined" && process.env && process.env.DEBUG && process.env.DEBUG.match(/json-rules-engine/) || typeof window !== "undefined" && window.localStorage && window.localStorage.debug && window.localStorage.debug.match(/json-rules-engine/)) {
+        console.log(message);
+      }
+    }
+  }
+});
+
+// ../../node_modules/lodash.isobjectlike/index.js
+var require_lodash = __commonJS({
+  "../../node_modules/lodash.isobjectlike/index.js"(exports, module) {
+    "use strict";
+    function isObjectLike(value) {
+      return !!value && typeof value == "object";
+    }
+    module.exports = isObjectLike;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/condition.js
+var require_condition = __commonJS({
+  "../../node_modules/json-rules-engine/dist/condition.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _debug = require_debug();
+    var _debug2 = _interopRequireDefault(_debug);
+    var _lodash = require_lodash();
+    var _lodash2 = _interopRequireDefault(_lodash);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var Condition = function() {
+      function Condition2(properties) {
+        _classCallCheck(this, Condition2);
+        if (!properties) throw new Error("Condition: constructor options required");
+        var booleanOperator = Condition2.booleanOperator(properties);
+        Object.assign(this, properties);
+        if (booleanOperator) {
+          var subConditions = properties[booleanOperator];
+          if (!Array.isArray(subConditions)) {
+            throw new Error('"' + booleanOperator + '" must be an array');
+          }
+          this.operator = booleanOperator;
+          this.priority = parseInt(properties.priority, 10) || 1;
+          this[booleanOperator] = subConditions.map(function(c) {
+            return new Condition2(c);
+          });
+        } else {
+          if (!properties.hasOwnProperty("fact")) throw new Error('Condition: constructor "fact" property required');
+          if (!properties.hasOwnProperty("operator")) throw new Error('Condition: constructor "operator" property required');
+          if (!properties.hasOwnProperty("value")) throw new Error('Condition: constructor "value" property required');
+          if (properties.hasOwnProperty("priority")) {
+            properties.priority = parseInt(properties.priority, 10);
+          }
+        }
+      }
+      _createClass(Condition2, [{
+        key: "toJSON",
+        value: function toJSON() {
+          var stringify2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+          var props = {};
+          if (this.priority) {
+            props.priority = this.priority;
+          }
+          var oper = Condition2.booleanOperator(this);
+          if (oper) {
+            props[oper] = this[oper].map(function(c) {
+              return c.toJSON(stringify2);
+            });
+          } else {
+            props.operator = this.operator;
+            props.value = this.value;
+            props.fact = this.fact;
+            if (this.factResult !== void 0) {
+              props.factResult = this.factResult;
+            }
+            if (this.result !== void 0) {
+              props.result = this.result;
+            }
+            if (this.params) {
+              props.params = this.params;
+            }
+            if (this.path) {
+              props.path = this.path;
+            }
+          }
+          if (stringify2) {
+            return JSON.stringify(props);
+          }
+          return props;
+        }
+        /**
+         * Interprets .value as either a primitive, or if a fact, retrieves the fact value
+         */
+      }, {
+        key: "_getValue",
+        value: function _getValue(almanac) {
+          var value = this.value;
+          if ((0, _lodash2.default)(value) && value.hasOwnProperty("fact")) {
+            return almanac.factValue(value.fact, value.params, value.path);
+          }
+          return Promise.resolve(value);
+        }
+        /**
+         * Takes the fact result and compares it to the condition 'value', using the operator
+         *   LHS                      OPER       RHS
+         * <fact + params + path>  <operator>  <value>
+         *
+         * @param   {Almanac} almanac
+         * @param   {Map} operatorMap - map of available operators, keyed by operator name
+         * @returns {Boolean} - evaluation result
+         */
+      }, {
+        key: "evaluate",
+        value: function evaluate(almanac, operatorMap) {
+          var _this = this;
+          if (!almanac) return Promise.reject(new Error("almanac required"));
+          if (!operatorMap) return Promise.reject(new Error("operatorMap required"));
+          if (this.isBooleanOperator()) return Promise.reject(new Error("Cannot evaluate() a boolean condition"));
+          var op = operatorMap.get(this.operator);
+          if (!op) return Promise.reject(new Error("Unknown operator: " + this.operator));
+          return this._getValue(almanac).then(function(rightHandSideValue) {
+            return almanac.factValue(_this.fact, _this.params, _this.path).then(function(leftHandSideValue) {
+              var result = op.evaluate(leftHandSideValue, rightHandSideValue);
+              (0, _debug2.default)("condition::evaluate <" + leftHandSideValue + " " + _this.operator + " " + rightHandSideValue + "?> (" + result + ")");
+              return { result, leftHandSideValue, rightHandSideValue, operator: _this.operator };
+            });
+          });
+        }
+        /**
+         * Returns the boolean operator for the condition
+         * If the condition is not a boolean condition, the result will be 'undefined'
+         * @return {string 'all' or 'any'}
+         */
+      }, {
+        key: "booleanOperator",
+        /**
+         * Returns the condition's boolean operator
+         * Instance version of Condition.isBooleanOperator
+         * @returns {string,undefined} - 'any', 'all', or undefined (if not a boolean condition)
+         */
+        value: function booleanOperator() {
+          return Condition2.booleanOperator(this);
+        }
+        /**
+         * Whether the operator is boolean ('all', 'any')
+         * @returns {Boolean}
+         */
+      }, {
+        key: "isBooleanOperator",
+        value: function isBooleanOperator() {
+          return Condition2.booleanOperator(this) !== void 0;
+        }
+      }], [{
+        key: "booleanOperator",
+        value: function booleanOperator(condition) {
+          if (condition.hasOwnProperty("any")) {
+            return "any";
+          } else if (condition.hasOwnProperty("all")) {
+            return "all";
+          }
+        }
+      }]);
+      return Condition2;
+    }();
+    exports.default = Condition;
+  }
+});
+
+// ../../node_modules/clone/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/clone/clone.js"(exports, module) {
+    "use strict";
+    var clone = function() {
+      "use strict";
+      function _instanceof(obj, type) {
+        return type != null && obj instanceof type;
+      }
+      var nativeMap;
+      try {
+        nativeMap = Map;
+      } catch (_) {
+        nativeMap = function() {
+        };
+      }
+      var nativeSet;
+      try {
+        nativeSet = Set;
+      } catch (_) {
+        nativeSet = function() {
+        };
+      }
+      var nativePromise;
+      try {
+        nativePromise = Promise;
+      } catch (_) {
+        nativePromise = function() {
+        };
+      }
+      function clone2(parent, circular, depth, prototype, includeNonEnumerable) {
+        if (typeof circular === "object") {
+          depth = circular.depth;
+          prototype = circular.prototype;
+          includeNonEnumerable = circular.includeNonEnumerable;
+          circular = circular.circular;
+        }
+        var allParents = [];
+        var allChildren = [];
+        var useBuffer = typeof Buffer != "undefined";
+        if (typeof circular == "undefined")
+          circular = true;
+        if (typeof depth == "undefined")
+          depth = Infinity;
+        function _clone(parent2, depth2) {
+          if (parent2 === null)
+            return null;
+          if (depth2 === 0)
+            return parent2;
+          var child;
+          var proto;
+          if (typeof parent2 != "object") {
+            return parent2;
+          }
+          if (_instanceof(parent2, nativeMap)) {
+            child = new nativeMap();
+          } else if (_instanceof(parent2, nativeSet)) {
+            child = new nativeSet();
+          } else if (_instanceof(parent2, nativePromise)) {
+            child = new nativePromise(function(resolve, reject) {
+              parent2.then(function(value) {
+                resolve(_clone(value, depth2 - 1));
+              }, function(err) {
+                reject(_clone(err, depth2 - 1));
+              });
+            });
+          } else if (clone2.__isArray(parent2)) {
+            child = [];
+          } else if (clone2.__isRegExp(parent2)) {
+            child = new RegExp(parent2.source, __getRegExpFlags(parent2));
+            if (parent2.lastIndex) child.lastIndex = parent2.lastIndex;
+          } else if (clone2.__isDate(parent2)) {
+            child = new Date(parent2.getTime());
+          } else if (useBuffer && Buffer.isBuffer(parent2)) {
+            if (Buffer.allocUnsafe) {
+              child = Buffer.allocUnsafe(parent2.length);
+            } else {
+              child = new Buffer(parent2.length);
+            }
+            parent2.copy(child);
+            return child;
+          } else if (_instanceof(parent2, Error)) {
+            child = Object.create(parent2);
+          } else {
+            if (typeof prototype == "undefined") {
+              proto = Object.getPrototypeOf(parent2);
+              child = Object.create(proto);
+            } else {
+              child = Object.create(prototype);
+              proto = prototype;
+            }
+          }
+          if (circular) {
+            var index = allParents.indexOf(parent2);
+            if (index != -1) {
+              return allChildren[index];
+            }
+            allParents.push(parent2);
+            allChildren.push(child);
+          }
+          if (_instanceof(parent2, nativeMap)) {
+            parent2.forEach(function(value, key) {
+              var keyChild = _clone(key, depth2 - 1);
+              var valueChild = _clone(value, depth2 - 1);
+              child.set(keyChild, valueChild);
+            });
+          }
+          if (_instanceof(parent2, nativeSet)) {
+            parent2.forEach(function(value) {
+              var entryChild = _clone(value, depth2 - 1);
+              child.add(entryChild);
+            });
+          }
+          for (var i in parent2) {
+            var attrs;
+            if (proto) {
+              attrs = Object.getOwnPropertyDescriptor(proto, i);
+            }
+            if (attrs && attrs.set == null) {
+              continue;
+            }
+            child[i] = _clone(parent2[i], depth2 - 1);
+          }
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(parent2);
+            for (var i = 0; i < symbols.length; i++) {
+              var symbol = symbols[i];
+              var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
+              if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+                continue;
+              }
+              child[symbol] = _clone(parent2[symbol], depth2 - 1);
+              if (!descriptor.enumerable) {
+                Object.defineProperty(child, symbol, {
+                  enumerable: false
+                });
+              }
+            }
+          }
+          if (includeNonEnumerable) {
+            var allPropertyNames = Object.getOwnPropertyNames(parent2);
+            for (var i = 0; i < allPropertyNames.length; i++) {
+              var propertyName = allPropertyNames[i];
+              var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
+              if (descriptor && descriptor.enumerable) {
+                continue;
+              }
+              child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
+              Object.defineProperty(child, propertyName, {
+                enumerable: false
+              });
+            }
+          }
+          return child;
+        }
+        return _clone(parent, depth);
+      }
+      clone2.clonePrototype = function clonePrototype(parent) {
+        if (parent === null)
+          return null;
+        var c = function() {
+        };
+        c.prototype = parent;
+        return new c();
+      };
+      function __objToStr(o) {
+        return Object.prototype.toString.call(o);
+      }
+      clone2.__objToStr = __objToStr;
+      function __isDate(o) {
+        return typeof o === "object" && __objToStr(o) === "[object Date]";
+      }
+      clone2.__isDate = __isDate;
+      function __isArray(o) {
+        return typeof o === "object" && __objToStr(o) === "[object Array]";
+      }
+      clone2.__isArray = __isArray;
+      function __isRegExp(o) {
+        return typeof o === "object" && __objToStr(o) === "[object RegExp]";
+      }
+      clone2.__isRegExp = __isRegExp;
+      function __getRegExpFlags(re) {
+        var flags = "";
+        if (re.global) flags += "g";
+        if (re.ignoreCase) flags += "i";
+        if (re.multiline) flags += "m";
+        return flags;
+      }
+      clone2.__getRegExpFlags = __getRegExpFlags;
+      return clone2;
+    }();
+    if (typeof module === "object" && module.exports) {
+      module.exports = clone;
+    }
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/rule-result.js
+var require_rule_result = __commonJS({
+  "../../node_modules/json-rules-engine/dist/rule-result.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _clone = require_clone();
+    var _clone2 = _interopRequireDefault(_clone);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var RuleResult = function() {
+      function RuleResult2(conditions, event, priority, name) {
+        _classCallCheck(this, RuleResult2);
+        this.conditions = (0, _clone2.default)(conditions);
+        this.event = (0, _clone2.default)(event);
+        this.priority = (0, _clone2.default)(priority);
+        this.name = (0, _clone2.default)(name);
+        this.result = null;
+      }
+      _createClass(RuleResult2, [{
+        key: "setResult",
+        value: function setResult(result) {
+          this.result = result;
+        }
+      }, {
+        key: "toJSON",
+        value: function toJSON() {
+          var stringify2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+          var props = {
+            conditions: this.conditions.toJSON(false),
+            event: this.event,
+            priority: this.priority,
+            name: this.name,
+            result: this.result
+          };
+          if (stringify2) {
+            return JSON.stringify(props);
+          }
+          return props;
+        }
+      }]);
+      return RuleResult2;
+    }();
+    exports.default = RuleResult;
+  }
+});
+
+// ../../node_modules/events/events.js
+var require_events = __commonJS({
+  "../../node_modules/events/events.js"(exports, module) {
+    "use strict";
+    var R = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    };
+    var ReflectOwnKeys;
+    if (R && typeof R.ownKeys === "function") {
+      ReflectOwnKeys = R.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+      };
+    } else {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      };
+    }
+    function ProcessEmitWarning(warning) {
+      if (console && console.warn) console.warn(warning);
+    }
+    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+      return value !== value;
+    };
+    function EventEmitter() {
+      EventEmitter.init.call(this);
+    }
+    module.exports = EventEmitter;
+    module.exports.once = once;
+    EventEmitter.EventEmitter = EventEmitter;
+    EventEmitter.prototype._events = void 0;
+    EventEmitter.prototype._eventsCount = 0;
+    EventEmitter.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      }
+    }
+    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+      enumerable: true,
+      get: function() {
+        return defaultMaxListeners;
+      },
+      set: function(arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+        }
+        defaultMaxListeners = arg;
+      }
+    });
+    EventEmitter.init = function() {
+      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+      }
+      this._maxListeners = n;
+      return this;
+    };
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+      return _getMaxListeners(this);
+    };
+    EventEmitter.prototype.emit = function emit(type) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+      var doError = type === "error";
+      var events = this._events;
+      if (events !== void 0)
+        doError = doError && events.error === void 0;
+      else if (!doError)
+        return false;
+      if (doError) {
+        var er;
+        if (args.length > 0)
+          er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+        err.context = er;
+        throw err;
+      }
+      var handler = events[type];
+      if (handler === void 0)
+        return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i = 0; i < len; ++i)
+          ReflectApply(listeners[i], this, args);
+      }
+      return true;
+    };
+    function _addListener(target, type, listener, prepend) {
+      var m;
+      var events;
+      var existing;
+      checkListener(listener);
+      events = target._events;
+      if (events === void 0) {
+        events = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type,
+            listener.listener ? listener.listener : listener
+          );
+          events = target._events;
+        }
+        existing = events[type];
+      }
+      if (existing === void 0) {
+        existing = events[type] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+          existing.warned = true;
+          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          w.name = "MaxListenersExceededWarning";
+          w.emitter = target;
+          w.type = type;
+          w.count = existing.length;
+          ProcessEmitWarning(w);
+        }
+      }
+      return target;
+    }
+    EventEmitter.prototype.addListener = function addListener(type, listener) {
+      return _addListener(this, type, listener, false);
+    };
+    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+    EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+          return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    function _onceWrap(target, type, listener) {
+      var state = { fired: false, wrapFn: void 0, target, type, listener };
+      var wrapped = onceWrapper.bind(state);
+      wrapped.listener = listener;
+      state.wrapFn = wrapped;
+      return wrapped;
+    }
+    EventEmitter.prototype.once = function once2(type, listener) {
+      checkListener(listener);
+      this.on(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+      checkListener(listener);
+      events = this._events;
+      if (events === void 0)
+        return this;
+      list = events[type];
+      if (list === void 0)
+        return this;
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit("removeListener", type, list.listener || listener);
+        }
+      } else if (typeof list !== "function") {
+        position = -1;
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+        if (position < 0)
+          return this;
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+        if (list.length === 1)
+          events[type] = list[0];
+        if (events.removeListener !== void 0)
+          this.emit("removeListener", type, originalListener || listener);
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+      var listeners, events, i;
+      events = this._events;
+      if (events === void 0)
+        return this;
+      if (events.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys2 = Object.keys(events);
+        var key;
+        for (i = 0; i < keys2.length; ++i) {
+          key = keys2[i];
+          if (key === "removeListener") continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events[type];
+      if (typeof listeners === "function") {
+        this.removeListener(type, listeners);
+      } else if (listeners !== void 0) {
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+      return this;
+    };
+    function _listeners(target, type, unwrap) {
+      var events = target._events;
+      if (events === void 0)
+        return [];
+      var evlistener = events[type];
+      if (evlistener === void 0)
+        return [];
+      if (typeof evlistener === "function")
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    }
+    EventEmitter.prototype.listeners = function listeners(type) {
+      return _listeners(this, type, true);
+    };
+    EventEmitter.prototype.rawListeners = function rawListeners(type) {
+      return _listeners(this, type, false);
+    };
+    EventEmitter.listenerCount = function(emitter, type) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type);
+      } else {
+        return listenerCount.call(emitter, type);
+      }
+    };
+    EventEmitter.prototype.listenerCount = listenerCount;
+    function listenerCount(type) {
+      var events = this._events;
+      if (events !== void 0) {
+        var evlistener = events[type];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    };
+    function arrayClone(arr, n) {
+      var copy = new Array(n);
+      for (var i = 0; i < n; ++i)
+        copy[i] = arr[i];
+      return copy;
+    }
+    function spliceOne(list, index) {
+      for (; index + 1 < list.length; index++)
+        list[index] = list[index + 1];
+      list.pop();
+    }
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+      }
+      return ret;
+    }
+    function once(emitter, name) {
+      return new Promise(function(resolve, reject) {
+        function errorListener(err) {
+          emitter.removeListener(name, resolver);
+          reject(err);
+        }
+        function resolver() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        ;
+        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+        if (name !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name, listener);
+        } else {
+          emitter.on(name, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name, function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name, wrapListener);
+          }
+          listener(arg);
+        });
+      } else {
+        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+      }
+    }
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/rule.js
+var require_rule = __commonJS({
+  "../../node_modules/json-rules-engine/dist/rule.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _condition = require_condition();
+    var _condition2 = _interopRequireDefault(_condition);
+    var _ruleResult = require_rule_result();
+    var _ruleResult2 = _interopRequireDefault(_ruleResult);
+    var _events = require_events();
+    var _debug = require_debug();
+    var _debug2 = _interopRequireDefault(_debug);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (!self2) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return call && (typeof call === "object" || typeof call === "function") ? call : self2;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });
+      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+    var Rule2 = function(_EventEmitter) {
+      _inherits(Rule3, _EventEmitter);
+      function Rule3(options) {
+        _classCallCheck(this, Rule3);
+        var _this = _possibleConstructorReturn(this, (Rule3.__proto__ || Object.getPrototypeOf(Rule3)).call(this));
+        if (typeof options === "string") {
+          options = JSON.parse(options);
+        }
+        if (options && options.conditions) {
+          _this.setConditions(options.conditions);
+        }
+        if (options && options.onSuccess) {
+          _this.on("success", options.onSuccess);
+        }
+        if (options && options.onFailure) {
+          _this.on("failure", options.onFailure);
+        }
+        if (options && (options.name || options.name === 0)) {
+          _this.setName(options.name);
+        }
+        var priority = options && options.priority || 1;
+        _this.setPriority(priority);
+        var event = options && options.event || { type: "unknown" };
+        _this.setEvent(event);
+        return _this;
+      }
+      _createClass(Rule3, [{
+        key: "setPriority",
+        value: function setPriority(priority) {
+          priority = parseInt(priority, 10);
+          if (priority <= 0) throw new Error("Priority must be greater than zero");
+          this.priority = priority;
+          return this;
+        }
+        /**
+         * Sets the name of the rule
+         * @param {any} name - any truthy input and zero is allowed
+         */
+      }, {
+        key: "setName",
+        value: function setName(name) {
+          if (!name && name !== 0) {
+            throw new Error('Rule "name" must be defined');
+          }
+          this.name = name;
+          return this;
+        }
+        /**
+         * Sets the conditions to run when evaluating the rule.
+         * @param {object} conditions - conditions, root element must be a boolean operator
+         */
+      }, {
+        key: "setConditions",
+        value: function setConditions(conditions) {
+          if (!conditions.hasOwnProperty("all") && !conditions.hasOwnProperty("any")) {
+            throw new Error('"conditions" root must contain a single instance of "all" or "any"');
+          }
+          this.conditions = new _condition2.default(conditions);
+          return this;
+        }
+        /**
+         * Sets the event to emit when the conditions evaluate truthy
+         * @param {object} event - event to emit
+         * @param {string} event.type - event name to emit on
+         * @param {string} event.params - parameters to emit as the argument of the event emission
+         */
+      }, {
+        key: "setEvent",
+        value: function setEvent(event) {
+          if (!event) throw new Error("Rule: setEvent() requires event object");
+          if (!event.hasOwnProperty("type")) throw new Error('Rule: setEvent() requires event object with "type" property');
+          this.event = {
+            type: event.type
+          };
+          if (event.params) this.event.params = event.params;
+          return this;
+        }
+        /**
+         * Sets the engine to run the rules under
+         * @param {object} engine
+         * @returns {Rule}
+         */
+      }, {
+        key: "setEngine",
+        value: function setEngine(engine) {
+          this.engine = engine;
+          return this;
+        }
+      }, {
+        key: "toJSON",
+        value: function toJSON() {
+          var stringify2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+          var props = {
+            conditions: this.conditions.toJSON(false),
+            priority: this.priority,
+            event: this.event,
+            name: this.name
+          };
+          if (stringify2) {
+            return JSON.stringify(props);
+          }
+          return props;
+        }
+        /**
+         * Priorizes an array of conditions based on "priority"
+         *   When no explicit priority is provided on the condition itself, the condition's priority is determine by its fact
+         * @param  {Condition[]} conditions
+         * @return {Condition[][]} prioritized two-dimensional array of conditions
+         *    Each outer array element represents a single priority(integer).  Inner array is
+         *    all conditions with that priority.
+         */
+      }, {
+        key: "prioritizeConditions",
+        value: function prioritizeConditions(conditions) {
+          var _this2 = this;
+          var factSets = conditions.reduce(function(sets, condition) {
+            var priority = condition.priority;
+            if (!priority) {
+              var fact = _this2.engine.getFact(condition.fact);
+              priority = fact && fact.priority || 1;
+            }
+            if (!sets[priority]) sets[priority] = [];
+            sets[priority].push(condition);
+            return sets;
+          }, {});
+          return Object.keys(factSets).sort(function(a, b) {
+            return Number(a) > Number(b) ? -1 : 1;
+          }).map(function(priority) {
+            return factSets[priority];
+          });
+        }
+        /**
+         * Evaluates the rule, starting with the root boolean operator and recursing down
+         * All evaluation is done within the context of an almanac
+         * @return {Promise(RuleResult)} rule evaluation result
+         */
+      }, {
+        key: "evaluate",
+        value: function evaluate(almanac) {
+          var _this3 = this;
+          var ruleResult = new _ruleResult2.default(this.conditions, this.event, this.priority, this.name);
+          var evaluateCondition = function evaluateCondition2(condition) {
+            if (condition.isBooleanOperator()) {
+              var subConditions = condition[condition.operator];
+              var comparisonPromise = void 0;
+              if (condition.operator === "all") {
+                comparisonPromise = all(subConditions);
+              } else {
+                comparisonPromise = any(subConditions);
+              }
+              return comparisonPromise.then(function(comparisonValue) {
+                var passes = comparisonValue === true;
+                condition.result = passes;
+                return passes;
+              });
+            } else {
+              return condition.evaluate(almanac, _this3.engine.operators).then(function(evaluationResult) {
+                var passes = evaluationResult.result;
+                condition.factResult = evaluationResult.leftHandSideValue;
+                condition.result = passes;
+                return passes;
+              });
+            }
+          };
+          var evaluateConditions = function evaluateConditions2(conditions, method) {
+            if (!Array.isArray(conditions)) conditions = [conditions];
+            return Promise.all(conditions.map(function(condition) {
+              return evaluateCondition(condition);
+            })).then(function(conditionResults) {
+              (0, _debug2.default)("rule::evaluateConditions results", conditionResults);
+              return method.call(conditionResults, function(result) {
+                return result === true;
+              });
+            });
+          };
+          var prioritizeAndRun = function prioritizeAndRun2(conditions, operator) {
+            if (conditions.length === 0) {
+              return Promise.resolve(true);
+            }
+            var method = Array.prototype.some;
+            if (operator === "all") {
+              method = Array.prototype.every;
+            }
+            var orderedSets = _this3.prioritizeConditions(conditions);
+            var cursor = Promise.resolve();
+            var _loop = function _loop2(i2) {
+              var set = orderedSets[i2];
+              var stop = false;
+              cursor = cursor.then(function(setResult) {
+                if (operator === "any" && setResult === true || stop) {
+                  (0, _debug2.default)("prioritizeAndRun::detected truthy result; skipping remaining conditions");
+                  stop = true;
+                  return true;
+                }
+                if (operator === "all" && setResult === false || stop) {
+                  (0, _debug2.default)("prioritizeAndRun::detected falsey result; skipping remaining conditions");
+                  stop = true;
+                  return false;
+                }
+                return evaluateConditions(set, method);
+              });
+            };
+            for (var i = 0; i < orderedSets.length; i++) {
+              _loop(i);
+            }
+            return cursor;
+          };
+          var any = function any2(conditions) {
+            return prioritizeAndRun(conditions, "any");
+          };
+          var all = function all2(conditions) {
+            return prioritizeAndRun(conditions, "all");
+          };
+          var processResult = function processResult2(result) {
+            ruleResult.setResult(result);
+            if (result) _this3.emit("success", ruleResult.event, almanac, ruleResult);
+            else _this3.emit("failure", ruleResult.event, almanac, ruleResult);
+            return ruleResult;
+          };
+          if (ruleResult.conditions.any) {
+            return any(ruleResult.conditions.any).then(function(result) {
+              return processResult(result);
+            });
+          } else {
+            return all(ruleResult.conditions.all).then(function(result) {
+              return processResult(result);
+            });
+          }
+        }
+      }]);
+      return Rule3;
+    }(_events.EventEmitter);
+    exports.default = Rule2;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/operator.js
+var require_operator = __commonJS({
+  "../../node_modules/json-rules-engine/dist/operator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var Operator = function() {
+      function Operator2(name, cb, factValueValidator) {
+        _classCallCheck(this, Operator2);
+        this.name = String(name);
+        if (!name) throw new Error("Missing operator name");
+        if (typeof cb !== "function") throw new Error("Missing operator callback");
+        this.cb = cb;
+        this.factValueValidator = factValueValidator;
+        if (!this.factValueValidator) this.factValueValidator = function() {
+          return true;
+        };
+      }
+      _createClass(Operator2, [{
+        key: "evaluate",
+        value: function evaluate(factValue, jsonValue) {
+          return this.factValueValidator(factValue) && this.cb(factValue, jsonValue);
+        }
+      }]);
+      return Operator2;
+    }();
+    exports.default = Operator;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/errors.js
+var require_errors = __commonJS({
+  "../../node_modules/json-rules-engine/dist/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (!self2) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return call && (typeof call === "object" || typeof call === "function") ? call : self2;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });
+      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+    var UndefinedFactError = exports.UndefinedFactError = function(_Error) {
+      _inherits(UndefinedFactError2, _Error);
+      function UndefinedFactError2() {
+        var _ref;
+        _classCallCheck(this, UndefinedFactError2);
+        for (var _len = arguments.length, props = Array(_len), _key = 0; _key < _len; _key++) {
+          props[_key] = arguments[_key];
+        }
+        var _this = _possibleConstructorReturn(this, (_ref = UndefinedFactError2.__proto__ || Object.getPrototypeOf(UndefinedFactError2)).call.apply(_ref, [this].concat(props)));
+        _this.code = "UNDEFINED_FACT";
+        return _this;
+      }
+      return UndefinedFactError2;
+    }(Error);
+  }
+});
+
+// ../../node_modules/fast-bind/bind-loop.js
+var require_bind_loop = __commonJS({
+  "../../node_modules/fast-bind/bind-loop.js"(exports, module) {
+    "use strict";
+    module.exports = function(boundThis) {
+      var f = this, ret;
+      if (arguments.length < 2)
+        ret = function() {
+          if (this instanceof ret) {
+            var ret_ = f.apply(this, arguments);
+            return Object(ret_) === ret_ ? ret_ : this;
+          } else
+            return f.apply(boundThis, arguments);
+        };
+      else {
+        var boundArgs = new Array(arguments.length - 1);
+        for (var i = 1; i < arguments.length; i++)
+          boundArgs[i - 1] = arguments[i];
+        ret = function() {
+          var boundLen = boundArgs.length, args = new Array(boundLen + arguments.length), i2;
+          for (i2 = 0; i2 < boundLen; i2++)
+            args[i2] = boundArgs[i2];
+          for (i2 = 0; i2 < arguments.length; i2++)
+            args[boundLen + i2] = arguments[i2];
+          if (this instanceof ret) {
+            var ret_ = f.apply(this, args);
+            return Object(ret_) === ret_ ? ret_ : this;
+          } else
+            return f.apply(boundThis, args);
+        };
+      }
+      ret.prototype = f.prototype;
+      return ret;
+    };
+  }
+});
+
+// ../../node_modules/curry2/index.js
+var require_curry2 = __commonJS({
+  "../../node_modules/curry2/index.js"(exports, module) {
+    "use strict";
+    var bind = Function.prototype.bind || require_bind_loop();
+    module.exports = curry2;
+    function curry2(fn, self2) {
+      var out = function() {
+        if (arguments.length === 0) return out;
+        return arguments.length > 1 ? fn.apply(self2, arguments) : bind.call(fn, self2, arguments[0]);
+      };
+      out.uncurry = function uncurry() {
+        return fn;
+      };
+      return out;
+    }
+  }
+});
+
+// ../../node_modules/brackets2dots/index.js
+var require_brackets2dots = __commonJS({
+  "../../node_modules/brackets2dots/index.js"(exports, module) {
+    "use strict";
+    module.exports = brackets2dots;
+    var REPLACE_BRACKETS = /\[([^\[\]]+)\]/g;
+    var LFT_RT_TRIM_DOTS = /^[.]*|[.]*$/g;
+    function brackets2dots(string) {
+      return {}.toString.call(string) == "[object String]" ? string.replace(REPLACE_BRACKETS, ".$1").replace(LFT_RT_TRIM_DOTS, "") : "";
+    }
+  }
+});
+
+// ../../node_modules/dotsplit.js/index.js
+var require_dotsplit = __commonJS({
+  "../../node_modules/dotsplit.js/index.js"(exports, module) {
+    "use strict";
+    var toString2 = Object.prototype.toString;
+    function dotsplit(string) {
+      var idx = -1;
+      var str = compact(normalize(string).split("."));
+      var end = str.length;
+      var out = [];
+      while (++idx < end) {
+        out.push(todots(str[idx]));
+      }
+      return out;
+    }
+    function normalize(string) {
+      return (toString2.call(string) === "[object String]" ? string : "").replace(/\\\./g, "\uFFFF");
+    }
+    function compact(arr) {
+      var idx = -1;
+      var end = arr.length;
+      var out = [];
+      while (++idx < end) {
+        if (arr[idx]) out.push(arr[idx]);
+      }
+      return out;
+    }
+    function todots(string) {
+      return string.replace(/\uffff/g, ".");
+    }
+    module.exports = dotsplit;
+  }
+});
+
+// ../../node_modules/selectn/index.js
+var require_selectn = __commonJS({
+  "../../node_modules/selectn/index.js"(exports, module) {
+    "use strict";
+    var curry2 = require_curry2();
+    var dotted = require_brackets2dots();
+    var splits = require_dotsplit();
+    var string = Object.prototype.toString;
+    module.exports = curry2(selectn);
+    function selectn(path, object) {
+      let idx = -1;
+      const seg = string.call(path) === "[object Array]" ? path : splits(dotted(path));
+      const end = seg.length;
+      let ref = end ? object : void 0;
+      while (++idx < end) {
+        if (Object(ref) !== ref) return void 0;
+        ref = ref[seg[idx]];
+      }
+      return typeof ref === "function" ? ref() : ref;
+    }
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/almanac.js
+var require_almanac = __commonJS({
+  "../../node_modules/json-rules-engine/dist/almanac.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+      return typeof obj;
+    } : function(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _fact = require_fact();
+    var _fact2 = _interopRequireDefault(_fact);
+    var _errors = require_errors();
+    var _debug = require_debug();
+    var _debug2 = _interopRequireDefault(_debug);
+    var _selectn = require_selectn();
+    var _selectn2 = _interopRequireDefault(_selectn);
+    var _lodash = require_lodash();
+    var _lodash2 = _interopRequireDefault(_lodash);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var Almanac = function() {
+      function Almanac2(factMap) {
+        var runtimeFacts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        _classCallCheck(this, Almanac2);
+        this.factMap = new Map(factMap);
+        this.factResultsCache = /* @__PURE__ */ new Map();
+        this.allowUndefinedFacts = Boolean(options.allowUndefinedFacts);
+        for (var factId in runtimeFacts) {
+          var fact = void 0;
+          if (runtimeFacts[factId] instanceof _fact2.default) {
+            fact = runtimeFacts[factId];
+          } else {
+            fact = new _fact2.default(factId, runtimeFacts[factId]);
+          }
+          this._addConstantFact(fact);
+          (0, _debug2.default)("almanac::constructor initialized runtime fact:" + fact.id + " with " + fact.value + "<" + _typeof(fact.value) + ">");
+        }
+      }
+      _createClass(Almanac2, [{
+        key: "_getFact",
+        value: function _getFact(factId) {
+          return this.factMap.get(factId);
+        }
+        /**
+         * Registers fact with the almanac
+         * @param {[type]} fact [description]
+         */
+      }, {
+        key: "_addConstantFact",
+        value: function _addConstantFact(fact) {
+          this.factMap.set(fact.id, fact);
+          this._setFactValue(fact, {}, fact.value);
+        }
+        /**
+         * Sets the computed value of a fact
+         * @param {Fact} fact
+         * @param {Object} params - values for differentiating this fact value from others, used for cache key
+         * @param {Mixed} value - computed value
+         */
+      }, {
+        key: "_setFactValue",
+        value: function _setFactValue(fact, params, value) {
+          var cacheKey = fact.getCacheKey(params);
+          var factValue = Promise.resolve(value);
+          if (cacheKey) {
+            this.factResultsCache.set(cacheKey, factValue);
+          }
+          return factValue;
+        }
+        /**
+         * Adds a constant fact during runtime.  Can be used mid-run() to add additional information
+         * @param {String} fact - fact identifier
+         * @param {Mixed} value - constant value of the fact
+         */
+      }, {
+        key: "addRuntimeFact",
+        value: function addRuntimeFact(factId, value) {
+          var fact = new _fact2.default(factId, value);
+          return this._addConstantFact(fact);
+        }
+        /**
+         * Returns the value of a fact, based on the given parameters.  Utilizes the 'almanac' maintained
+         * by the engine, which cache's fact computations based on parameters provided
+         * @param  {string} factId - fact identifier
+         * @param  {Object} params - parameters to feed into the fact.  By default, these will also be used to compute the cache key
+         * @param  {String} path - object
+         * @return {Promise} a promise which will resolve with the fact computation.
+         */
+      }, {
+        key: "factValue",
+        value: function factValue(factId) {
+          var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          var path = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+          var factValuePromise = void 0;
+          var fact = this._getFact(factId);
+          if (fact === void 0) {
+            if (this.allowUndefinedFacts) {
+              return Promise.resolve(void 0);
+            } else {
+              return Promise.reject(new _errors.UndefinedFactError("Undefined fact: " + factId));
+            }
+          }
+          if (fact.isConstant()) {
+            factValuePromise = Promise.resolve(fact.calculate(params, this));
+          } else {
+            var cacheKey = fact.getCacheKey(params);
+            var cacheVal = cacheKey && this.factResultsCache.get(cacheKey);
+            if (cacheVal) {
+              factValuePromise = Promise.resolve(cacheVal);
+              (0, _debug2.default)("almanac::factValue cache hit for fact:" + factId);
+            } else {
+              (0, _debug2.default)("almanac::factValue cache miss for fact:" + factId + "; calculating");
+              factValuePromise = this._setFactValue(fact, params, fact.calculate(params, this));
+            }
+          }
+          if (path) {
+            return factValuePromise.then(function(factValue2) {
+              if ((0, _lodash2.default)(factValue2)) {
+                var pathValue = (0, _selectn2.default)(path)(factValue2);
+                (0, _debug2.default)("condition::evaluate extracting object property " + path + ", received: " + pathValue);
+                return pathValue;
+              } else {
+                (0, _debug2.default)("condition::evaluate could not compute object path(" + path + ") of non-object: " + factValue2 + " <" + (typeof factValue2 === "undefined" ? "undefined" : _typeof(factValue2)) + ">; continuing with " + factValue2);
+                return factValue2;
+              }
+            });
+          }
+          return factValuePromise;
+        }
+      }]);
+      return Almanac2;
+    }();
+    exports.default = Almanac;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/engine-facts.js
+var require_engine_facts = __commonJS({
+  "../../node_modules/json-rules-engine/dist/engine-facts.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var SuccessEventFact = function SuccessEventFact2() {
+      var successTriggers = [];
+      return function() {
+        var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        if (params.event) {
+          successTriggers.push(params.event);
+        }
+        return successTriggers;
+      };
+    };
+    exports.SuccessEventFact = SuccessEventFact;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/engine-default-operators.js
+var require_engine_default_operators = __commonJS({
+  "../../node_modules/json-rules-engine/dist/engine-default-operators.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _operator = require_operator();
+    var _operator2 = _interopRequireDefault(_operator);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var Operators = [];
+    Operators.push(new _operator2.default("equal", function(a, b) {
+      return a === b;
+    }));
+    Operators.push(new _operator2.default("notEqual", function(a, b) {
+      return a !== b;
+    }));
+    Operators.push(new _operator2.default("in", function(a, b) {
+      return b.indexOf(a) > -1;
+    }));
+    Operators.push(new _operator2.default("notIn", function(a, b) {
+      return b.indexOf(a) === -1;
+    }));
+    Operators.push(new _operator2.default("contains", function(a, b) {
+      return a.indexOf(b) > -1;
+    }, Array.isArray));
+    Operators.push(new _operator2.default("doesNotContain", function(a, b) {
+      return a.indexOf(b) === -1;
+    }, Array.isArray));
+    function numberValidator(factValue) {
+      return Number.parseFloat(factValue).toString() !== "NaN";
+    }
+    Operators.push(new _operator2.default("lessThan", function(a, b) {
+      return a < b;
+    }, numberValidator));
+    Operators.push(new _operator2.default("lessThanInclusive", function(a, b) {
+      return a <= b;
+    }, numberValidator));
+    Operators.push(new _operator2.default("greaterThan", function(a, b) {
+      return a > b;
+    }, numberValidator));
+    Operators.push(new _operator2.default("greaterThanInclusive", function(a, b) {
+      return a >= b;
+    }, numberValidator));
+    exports.default = Operators;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/engine.js
+var require_engine = __commonJS({
+  "../../node_modules/json-rules-engine/dist/engine.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.FINISHED = exports.RUNNING = exports.READY = void 0;
+    var _createClass = /* @__PURE__ */ function() {
+      function defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    var _fact = require_fact();
+    var _fact2 = _interopRequireDefault(_fact);
+    var _rule = require_rule();
+    var _rule2 = _interopRequireDefault(_rule);
+    var _operator = require_operator();
+    var _operator2 = _interopRequireDefault(_operator);
+    var _almanac = require_almanac();
+    var _almanac2 = _interopRequireDefault(_almanac);
+    var _events = require_events();
+    var _engineFacts = require_engine_facts();
+    var _engineDefaultOperators = require_engine_default_operators();
+    var _engineDefaultOperators2 = _interopRequireDefault(_engineDefaultOperators);
+    var _debug = require_debug();
+    var _debug2 = _interopRequireDefault(_debug);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (!self2) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return call && (typeof call === "object" || typeof call === "function") ? call : self2;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });
+      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+    var READY = exports.READY = "READY";
+    var RUNNING = exports.RUNNING = "RUNNING";
+    var FINISHED = exports.FINISHED = "FINISHED";
+    var Engine2 = function(_EventEmitter) {
+      _inherits(Engine3, _EventEmitter);
+      function Engine3() {
+        var rules = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        _classCallCheck(this, Engine3);
+        var _this = _possibleConstructorReturn(this, (Engine3.__proto__ || Object.getPrototypeOf(Engine3)).call(this));
+        _this.rules = [];
+        _this.allowUndefinedFacts = options.allowUndefinedFacts || false;
+        _this.operators = /* @__PURE__ */ new Map();
+        _this.facts = /* @__PURE__ */ new Map();
+        _this.status = READY;
+        rules.map(function(r) {
+          return _this.addRule(r);
+        });
+        _engineDefaultOperators2.default.map(function(o) {
+          return _this.addOperator(o);
+        });
+        return _this;
+      }
+      _createClass(Engine3, [{
+        key: "addRule",
+        value: function addRule(properties) {
+          if (!properties) throw new Error("Engine: addRule() requires options");
+          if (!properties.hasOwnProperty("conditions")) throw new Error('Engine: addRule() argument requires "conditions" property');
+          if (!properties.hasOwnProperty("event")) throw new Error('Engine: addRule() argument requires "event" property');
+          var rule = void 0;
+          if (properties instanceof _rule2.default) {
+            rule = properties;
+          } else {
+            rule = new _rule2.default(properties);
+          }
+          rule.setEngine(this);
+          this.rules.push(rule);
+          this.prioritizedRules = null;
+          return this;
+        }
+        /**
+         * Remove a rule from the engine
+         * @param {object|Rule} rule - rule definition. Must be a instance of Rule
+         */
+      }, {
+        key: "removeRule",
+        value: function removeRule(rule) {
+          if (rule instanceof _rule2.default === false) throw new Error("Engine: removeRule() rule must be a instance of Rule");
+          var index = this.rules.indexOf(rule);
+          if (index === -1) return false;
+          this.prioritizedRules = null;
+          return Boolean(this.rules.splice(index, 1).length);
+        }
+        /**
+         * Add a custom operator definition
+         * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
+         * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered.
+         */
+      }, {
+        key: "addOperator",
+        value: function addOperator(operatorOrName, cb) {
+          var operator = void 0;
+          if (operatorOrName instanceof _operator2.default) {
+            operator = operatorOrName;
+          } else {
+            operator = new _operator2.default(operatorOrName, cb);
+          }
+          (0, _debug2.default)("engine::addOperator name:" + operator.name);
+          this.operators.set(operator.name, operator);
+        }
+        /**
+         * Remove a custom operator definition
+         * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
+         * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered.
+         */
+      }, {
+        key: "removeOperator",
+        value: function removeOperator(operatorOrName) {
+          var operatorName = void 0;
+          if (operatorOrName instanceof _operator2.default) {
+            operatorName = operatorOrName.name;
+          } else {
+            operatorName = operatorOrName;
+          }
+          return this.operators.delete(operatorName);
+        }
+        /**
+         * Add a fact definition to the engine.  Facts are called by rules as they are evaluated.
+         * @param {object|Fact} id - fact identifier or instance of Fact
+         * @param {function} definitionFunc - function to be called when computing the fact value for a given rule
+         * @param {Object} options - options to initialize the fact with. used when "id" is not a Fact instance
+         */
+      }, {
+        key: "addFact",
+        value: function addFact(id, valueOrMethod, options) {
+          var factId = id;
+          var fact = void 0;
+          if (id instanceof _fact2.default) {
+            factId = id.id;
+            fact = id;
+          } else {
+            fact = new _fact2.default(id, valueOrMethod, options);
+          }
+          (0, _debug2.default)("engine::addFact id:" + factId);
+          this.facts.set(factId, fact);
+          return this;
+        }
+        /**
+         * Add a fact definition to the engine.  Facts are called by rules as they are evaluated.
+         * @param {object|Fact} id - fact identifier or instance of Fact
+         */
+      }, {
+        key: "removeFact",
+        value: function removeFact(factOrId) {
+          var factId = void 0;
+          if (!(factOrId instanceof _fact2.default)) {
+            factId = factOrId;
+          } else {
+            factId = factOrId.id;
+          }
+          return this.facts.delete(factId);
+        }
+        /**
+         * Iterates over the engine rules, organizing them by highest -> lowest priority
+         * @return {Rule[][]} two dimensional array of Rules.
+         *    Each outer array element represents a single priority(integer).  Inner array is
+         *    all rules with that priority.
+         */
+      }, {
+        key: "prioritizeRules",
+        value: function prioritizeRules() {
+          if (!this.prioritizedRules) {
+            var ruleSets = this.rules.reduce(function(sets, rule) {
+              var priority = rule.priority;
+              if (!sets[priority]) sets[priority] = [];
+              sets[priority].push(rule);
+              return sets;
+            }, {});
+            this.prioritizedRules = Object.keys(ruleSets).sort(function(a, b) {
+              return Number(a) > Number(b) ? -1 : 1;
+            }).map(function(priority) {
+              return ruleSets[priority];
+            });
+          }
+          return this.prioritizedRules;
+        }
+        /**
+         * Stops the rules engine from running the next priority set of Rules.  All remaining rules will be resolved as undefined,
+         * and no further events emitted.  Since rules of the same priority are evaluated in parallel(not series), other rules of
+         * the same priority may still emit events, even though the engine is in a "finished" state.
+         * @return {Engine}
+         */
+      }, {
+        key: "stop",
+        value: function stop() {
+          this.status = FINISHED;
+          return this;
+        }
+        /**
+         * Returns a fact by fact-id
+         * @param  {string} factId - fact identifier
+         * @return {Fact} fact instance, or undefined if no such fact exists
+         */
+      }, {
+        key: "getFact",
+        value: function getFact(factId) {
+          return this.facts.get(factId);
+        }
+        /**
+         * Runs an array of rules
+         * @param  {Rule[]} array of rules to be evaluated
+         * @return {Promise} resolves when all rules in the array have been evaluated
+         */
+      }, {
+        key: "evaluateRules",
+        value: function evaluateRules(ruleArray, almanac) {
+          var _this2 = this;
+          return Promise.all(ruleArray.map(function(rule) {
+            if (_this2.status !== RUNNING) {
+              (0, _debug2.default)("engine::run status:" + _this2.status + "; skipping remaining rules");
+              return;
+            }
+            return rule.evaluate(almanac).then(function(ruleResult) {
+              (0, _debug2.default)("engine::run ruleResult:" + ruleResult.result);
+              if (ruleResult.result) {
+                _this2.emit("success", rule.event, almanac, ruleResult);
+                _this2.emit(rule.event.type, rule.event.params, almanac, ruleResult);
+                almanac.factValue("success-events", { event: rule.event });
+              } else {
+                _this2.emit("failure", rule.event, almanac, ruleResult);
+              }
+            });
+          }));
+        }
+        /**
+         * Runs the rules engine
+         * @param  {Object} runtimeFacts - fact values known at runtime
+         * @param  {Object} runOptions - run options
+         * @return {Promise} resolves when the engine has completed running
+         */
+      }, {
+        key: "run",
+        value: function run() {
+          var _this3 = this;
+          var runtimeFacts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          (0, _debug2.default)("engine::run started");
+          (0, _debug2.default)("engine::run runtimeFacts:", runtimeFacts);
+          runtimeFacts["success-events"] = new _fact2.default("success-events", (0, _engineFacts.SuccessEventFact)(), { cache: false });
+          this.status = RUNNING;
+          var almanac = new _almanac2.default(this.facts, runtimeFacts, { allowUndefinedFacts: this.allowUndefinedFacts });
+          var orderedSets = this.prioritizeRules();
+          var cursor = Promise.resolve();
+          return new Promise(function(resolve, reject) {
+            orderedSets.map(function(set) {
+              cursor = cursor.then(function() {
+                return _this3.evaluateRules(set, almanac);
+              }).catch(reject);
+              return cursor;
+            });
+            cursor.then(function() {
+              _this3.status = FINISHED;
+              (0, _debug2.default)("engine::run completed");
+              return almanac.factValue("success-events");
+            }).then(function(events) {
+              resolve({
+                events,
+                almanac
+              });
+            }).catch(reject);
+          });
+        }
+      }]);
+      return Engine3;
+    }(_events.EventEmitter);
+    exports.default = Engine2;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/json-rules-engine.js
+var require_json_rules_engine = __commonJS({
+  "../../node_modules/json-rules-engine/dist/json-rules-engine.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.Engine = exports.Operator = exports.Rule = exports.Fact = void 0;
+    exports.default = function(rules, options) {
+      return new _engine2.default(rules, options);
+    };
+    var _engine = require_engine();
+    var _engine2 = _interopRequireDefault(_engine);
+    var _fact = require_fact();
+    var _fact2 = _interopRequireDefault(_fact);
+    var _rule = require_rule();
+    var _rule2 = _interopRequireDefault(_rule);
+    var _operator = require_operator();
+    var _operator2 = _interopRequireDefault(_operator);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    exports.Fact = _fact2.default;
+    exports.Rule = _rule2.default;
+    exports.Operator = _operator2.default;
+    exports.Engine = _engine2.default;
+  }
+});
+
+// ../../node_modules/json-rules-engine/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/json-rules-engine/dist/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_json_rules_engine();
+  }
+});
+
+// ../packlytics/dist/utils/get-packlytics-id.js
+function sha256(ascii) {
+  function rightRotate(value, amount) {
+    return value >>> amount | value << 32 - amount;
+  }
+  const mathPow = Math.pow;
+  const maxWord = mathPow(2, 32);
+  const lengthProperty = "length";
+  let i, j;
+  let result = "";
+  const words = [];
+  const asciiBitLength = ascii[lengthProperty] * 8;
+  let hash2 = sha256.h = sha256.h || [];
+  const k = sha256.k = sha256.k || [];
+  let primeCounter = k[lengthProperty];
+  const isComposite = {};
+  for (let candidate = 2; primeCounter < 64; candidate++) {
+    if (!isComposite[candidate]) {
+      for (i = 0; i < 313; i += candidate) {
+        isComposite[i] = candidate;
+      }
+      hash2[primeCounter] = mathPow(candidate, 0.5) * maxWord | 0;
+      k[primeCounter++] = mathPow(candidate, 1 / 3) * maxWord | 0;
+    }
+  }
+  ascii += "\x80";
+  while (ascii[lengthProperty] % 64 - 56)
+    ascii += "\0";
+  for (i = 0; i < ascii[lengthProperty]; i++) {
+    j = ascii.charCodeAt(i);
+    if (j >> 8)
+      return;
+    words[i >> 2] |= j << (3 - i) % 4 * 8;
+  }
+  words[words[lengthProperty]] = asciiBitLength / maxWord | 0;
+  words[words[lengthProperty]] = asciiBitLength;
+  for (j = 0; j < words[lengthProperty]; ) {
+    const w = words.slice(j, j += 16);
+    const oldHash = hash2;
+    hash2 = hash2.slice(0, 8);
+    for (i = 0; i < 64; i++) {
+      const i2 = i + j;
+      const w15 = w[i - 15], w2 = w[i - 2];
+      const a = hash2[0], e = hash2[4];
+      const temp1 = hash2[7] + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) + // S1
+      (e & hash2[5] ^ ~e & hash2[6]) + // ch
+      k[i] + // Expand the message schedule if needed
+      (w[i] = i < 16 ? w[i] : w[i - 16] + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ w15 >>> 3) + // s0
+      w[i - 7] + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ w2 >>> 10) | // s1
+      0);
+      const temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) + // S0
+      (a & hash2[1] ^ a & hash2[2] ^ hash2[1] & hash2[2]);
+      hash2 = [temp1 + temp2 | 0].concat(hash2);
+      hash2[4] = hash2[4] + temp1 | 0;
+    }
+    for (i = 0; i < 8; i++) {
+      hash2[i] = hash2[i] + oldHash[i] | 0;
+    }
+  }
+  for (i = 0; i < 8; i++) {
+    for (j = 3; j + 1; j--) {
+      const b = hash2[i] >> j * 8 & 255;
+      result += (b < 16 ? 0 : "") + b.toString(16);
+    }
+  }
+  return result;
+}
+function createHash(data) {
+  const hash2 = sha256(data);
+  return [
+    hash2?.substring(0, 8),
+    hash2?.substring(8, 12),
+    hash2?.substring(12, 16),
+    hash2?.substring(16, 20),
+    hash2?.substring(20, 32)
+  ].join("-");
+}
+function getPacklyticsId(data, secret) {
+  const currentDate = /* @__PURE__ */ new Date();
+  const formattedDate = currentDate.toLocaleDateString("en-US");
+  const salt = sha256(formattedDate + secret);
+  return createHash(data + salt);
+}
+
+// ../../node_modules/intl-parse-accept-language/dist/intl-parse-accept-language.esm.js
+var defaultValidate = function defaultValidate2(locale) {
+  return locale;
+};
+var parseAcceptLanguage = function parseAcceptLanguage2(languageHeaderValue, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (!languageHeaderValue) return [];
+  var _options = options, _options$ignoreWildca = _options.ignoreWildcard, ignoreWildcard = _options$ignoreWildca === void 0 ? true : _options$ignoreWildca, _options$validate = _options.validate, validate = _options$validate === void 0 ? defaultValidate : _options$validate;
+  return languageHeaderValue.split(",").map(function(lang) {
+    var _lang$split = lang.split(";"), locale = _lang$split[0], _lang$split$ = _lang$split[1], q = _lang$split$ === void 0 ? "q=1" : _lang$split$;
+    var trimmedLocale = locale.trim();
+    var numQ = Number(q.replace(/q ?=/, ""));
+    if (isNaN(numQ)) return [0, trimmedLocale];
+    return [numQ, trimmedLocale];
+  }).sort(function(_ref, _ref2) {
+    var q1 = _ref[0];
+    var q2 = _ref2[0];
+    return q2 - q1;
+  }).flatMap(function(_ref3) {
+    var locale = _ref3[1];
+    if (locale === "*" && ignoreWildcard) return [];
+    try {
+      return validate(locale) || [];
+    } catch (_unused) {
+      return [];
+    }
+  });
+};
+
+// ../packlytics/dist/utils/get-headers.js
+function getHeaders(requestOrHeaders) {
+  if (requestOrHeaders instanceof Request) {
+    return requestOrHeaders.headers;
+  }
+  return requestOrHeaders;
+}
+
+// ../packlytics/dist/utils/get-client-locales.js
+function getClientLocales(requestOrHeaders) {
+  let headers = getHeaders(requestOrHeaders);
+  let acceptLanguage = headers.get("Accept-Language");
+  if (!acceptLanguage)
+    return void 0;
+  let locales = parseAcceptLanguage(acceptLanguage, {
+    validate: Intl.DateTimeFormat.supportedLocalesOf,
+    ignoreWildcard: true
+  });
+  if (locales.length === 0)
+    return void 0;
+  return locales;
+}
+
+// ../packlytics/dist/utils/sanatize-payload.js
+var sanitizePayload = (data) => {
+  let dataStr = JSON.stringify(data);
   const sensitiveFields = [
     "username",
     "user",
@@ -1823,33 +4704,33 @@ import {
 } from "@shopify/remix-oxygen";
 
 // src/session/cookies-utils.tsx
-var import_cookie2 = __toESM(require_cookie());
+var import_cookie2 = __toESM(require_cookie(), 1);
 var tokenHash = "xxxx-4xxx-xxxx-xxxxxxxxxxxx";
 function hasUserConsent(request) {
   const cookies = import_cookie2.default.parse(request.headers.get("Cookie"));
   return cookies[PACK_USER_CONSENT_COOKIE_ID] ? cookies[PACK_USER_CONSENT_COOKIE_ID] === "true" : true;
 }
 function buildRandomUUID() {
-  let hash = "";
+  let hash2 = "";
   try {
     const crypto2 = window.crypto;
     const randomValuesArray = new Uint16Array(31);
     crypto2.getRandomValues(randomValuesArray);
     let i = 0;
-    hash = tokenHash.replace(/[x]/g, (c) => {
+    hash2 = tokenHash.replace(/[x]/g, (c) => {
       const r = randomValuesArray[i] % 16;
       const v = c === "x" ? r : r & 3 | 8;
       i++;
       return v.toString(16);
     });
   } catch (err) {
-    hash = tokenHash.replace(/[x]/g, (c) => {
+    hash2 = tokenHash.replace(/[x]/g, (c) => {
       const r = Math.random() * 16 | 0;
       const v = c === "x" ? r : r & 3 | 8;
       return v.toString(16);
     });
   }
-  return `${hexTime()}-${hash}`;
+  return `${hexTime()}-${hash2}`;
 }
 function hexTime() {
   let dateNumber = 0;
@@ -1923,6 +4804,8 @@ import {
   createCookie as createCookie2,
   createCookieSessionStorage as createCookieSessionStorage2
 } from "@shopify/remix-oxygen";
+var import_debug = __toESM(require_browser(), 1);
+var debug = (0, import_debug.default)("pack:ab-testing:test-session");
 function isSafari2(userAgent) {
   if (!userAgent) return false;
   return /Safari\//.test(userAgent) && !/Chrome\//.test(userAgent) && !/Chromium\//.test(userAgent) && !/Edg\//.test(userAgent) && !/Firefox\//.test(userAgent);
@@ -1939,11 +4822,17 @@ var PackTestSession = class {
     this.#sessionStorage = sessionStorage;
     this.#initialData = {
       test_data: this.#session.get("test_data"),
-      test_expire_at: this.#session.get("test_expire_at")
+      test_expire_at: this.#session.get("test_expire_at"),
+      test_rules_cache: this.#session.get("test_rules_cache"),
+      test_rules_cache_timestamp: this.#session.get("test_rules_cache_timestamp")
     };
   }
   static async init(request, secrets) {
     const userAgent = request.headers.get("User-Agent");
+    debug("[PackTestSession.init] Initializing test session", {
+      hasSecrets: secrets.length > 0,
+      userAgent: userAgent?.substring(0, 50)
+    });
     const storage = createCookieSessionStorage2({
       cookie: createCookie2(PACK_TEST_COOKIE_ID, {
         secure: isSafari2(userAgent) && process.env.NODE_ENV === "development" ? false : true,
@@ -1958,24 +4847,60 @@ var PackTestSession = class {
     if (!sessionId) {
       sessionId = crypto.randomUUID();
       session.set("test_session_id", sessionId);
+      debug("[PackTestSession.init] Generated new session ID", { sessionId });
+    } else {
+      debug("[PackTestSession.init] Using existing session ID", { sessionId });
     }
     return new this(sessionId, storage, session);
   }
   getTestData() {
-    return this.#session.get("test_data");
+    const testData = this.#session.get("test_data");
+    debug("[getTestData] Called", {
+      sessionId: this.id,
+      hasTestData: !!testData,
+      hasIsFirstExposure: testData && "isFirstExposure" in testData,
+      isFirstExposure: testData ? testData.isFirstExposure : void 0,
+      testId: testData?.id,
+      testHandle: testData?.handle
+    });
+    if (testData && "isFirstExposure" in testData) {
+      const { isFirstExposure, ...cleanTestData } = testData;
+      debug("[getTestData] Cleaning session data, removing isFirstExposure flag", {
+        sessionId: this.id,
+        isFirstExposure
+      });
+      this.#session.set("test_data", cleanTestData);
+      this.#isDirty = true;
+      return cleanTestData;
+    }
+    return testData;
   }
   getExpireAt() {
     return this.#session.get("test_expire_at");
   }
   setTestData(testData) {
+    debug("[setTestData] Setting test data", {
+      sessionId: this.id,
+      testId: testData?.id,
+      testHandle: testData?.handle,
+      variantId: testData?.testVariant?.id,
+      variantHandle: testData?.testVariant?.handle
+    });
     this.#isDirty = true;
     this.#session.set("test_data", testData);
   }
   setExpireAt(expireAt) {
+    debug("[setExpireAt] Setting expiry", {
+      sessionId: this.id,
+      expireAt
+    });
     this.#isDirty = true;
     this.#session.set("test_expire_at", expireAt);
   }
   clearTestData() {
+    debug("[clearTestData] Clearing test data and expiry", {
+      sessionId: this.id
+    });
     this.#isDirty = true;
     this.#session.unset("test_data");
     this.#session.unset("test_expire_at");
@@ -1983,95 +4908,721 @@ var PackTestSession = class {
   hasTestData() {
     return this.#session.has("test_data");
   }
+  // Test rules cache methods
+  getTestRulesCache() {
+    return this.#session.get("test_rules_cache");
+  }
+  getTestRulesCacheTimestamp() {
+    return this.#session.get("test_rules_cache_timestamp");
+  }
+  setTestRulesCache(rules, timestamp) {
+    debug("[setTestRulesCache] Caching test rules", {
+      sessionId: this.id,
+      rulesCount: rules.length,
+      timestamp: new Date(timestamp).toISOString()
+    });
+    this.#isDirty = true;
+    this.#session.set("test_rules_cache", rules);
+    this.#session.set("test_rules_cache_timestamp", timestamp);
+  }
+  clearTestRulesCache() {
+    debug("[clearTestRulesCache] Clearing rules cache", {
+      sessionId: this.id
+    });
+    this.#isDirty = true;
+    this.#session.unset("test_rules_cache");
+    this.#session.unset("test_rules_cache_timestamp");
+  }
+  isTestRulesCacheValid(cacheDurationMs = 60 * 60 * 1e3) {
+    const timestamp = this.getTestRulesCacheTimestamp();
+    if (!timestamp) {
+      debug("[isTestRulesCacheValid] No cache timestamp found", {
+        sessionId: this.id
+      });
+      return false;
+    }
+    const isValid = Date.now() - timestamp < cacheDurationMs;
+    debug("[isTestRulesCacheValid] Cache validity check", {
+      sessionId: this.id,
+      isValid,
+      cacheAge: Math.floor((Date.now() - timestamp) / 1e3) + "s",
+      maxAge: Math.floor(cacheDurationMs / 1e3) + "s"
+    });
+    return isValid;
+  }
   hasChanges() {
     const currentTestData = this.getTestData();
     const currentExpireAt = this.getExpireAt();
+    const currentTestRulesCache = this.getTestRulesCache();
+    const currentTestRulesCacheTimestamp = this.getTestRulesCacheTimestamp();
     const testDataChanged = JSON.stringify(currentTestData) !== JSON.stringify(this.#initialData.test_data);
     const expireAtChanged = currentExpireAt !== this.#initialData.test_expire_at;
-    return testDataChanged || expireAtChanged || this.#isDirty;
+    const testRulesCacheChanged = JSON.stringify(currentTestRulesCache) !== JSON.stringify(this.#initialData.test_rules_cache);
+    const testRulesCacheTimestampChanged = currentTestRulesCacheTimestamp !== this.#initialData.test_rules_cache_timestamp;
+    const hasChanges = testDataChanged || expireAtChanged || testRulesCacheChanged || testRulesCacheTimestampChanged || this.#isDirty;
+    debug("[hasChanges] Checking for changes", {
+      sessionId: this.id,
+      hasChanges,
+      testDataChanged,
+      expireAtChanged,
+      testRulesCacheChanged,
+      testRulesCacheTimestampChanged,
+      isDirty: this.#isDirty
+    });
+    return hasChanges;
+  }
+  commit() {
+    debug("[commit] Committing session", {
+      sessionId: this.id,
+      isDirty: this.#isDirty,
+      hasTestData: !!this.getTestData()
+    });
+    this.#isDirty = false;
+    this.#initialData = {
+      test_data: this.getTestData(),
+      test_expire_at: this.getExpireAt(),
+      test_rules_cache: this.getTestRulesCache(),
+      test_rules_cache_timestamp: this.getTestRulesCacheTimestamp()
+    };
+    return this.#sessionStorage.commitSession(this.#session);
+  }
+  destroy() {
+    debug("[destroy] Destroying session", {
+      sessionId: this.id
+    });
+    this.#isDirty = true;
+    this.#session.unset("test_data");
+    this.#session.unset("test_expire_at");
+    this.#session.unset("test_rules_cache");
+    this.#session.unset("test_rules_cache_timestamp");
+    return this.#sessionStorage.destroySession(this.#session);
+  }
+};
+
+// src/create-pack-client.ts
+var cookie3 = __toESM(require_cookie(), 1);
+import { PackClient } from "@pack/client";
+import { CacheCustom, createWithCache } from "@shopify/hydrogen";
+
+// src/tests/test.ts
+var cookie2 = __toESM(require_cookie(), 1);
+
+// src/tests/local-test-resolver.ts
+var import_json_rules_engine = __toESM(require_dist(), 1);
+var import_debug2 = __toESM(require_browser(), 1);
+var debug2 = (0, import_debug2.default)("pack:ab-testing:local-resolver");
+var LocalTestResolver = class {
+  testRules = [];
+  constructor() {
+  }
+  /**
+   * Set test rules (from the shared cache)
+   */
+  setTestRules(rules) {
+    this.testRules = rules;
+  }
+  /**
+   * Check if rules are loaded
+   */
+  hasRules() {
+    return this.testRules.length > 0;
+  }
+  /**
+   * Check if a specific test is still active in the current rules
+   */
+  isTestActive(testId) {
+    return this.testRules.some((test) => test.id === testId);
+  }
+  /**
+   * Get fresh test data by ID from current rules
+   */
+  getTestById(testId) {
+    return this.testRules.find((test) => test.id === testId) || null;
+  }
+  /**
+   * Get random number for test assignment
+   */
+  getRandomNumber(max, min = 0) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+  }
+  /**
+   * Evaluate test rules and assign a variant
+   */
+  async assignTest(attributes, _sessionId) {
+    debug2("[Pack Test LocalResolver] Starting test assignment:", JSON.stringify({
+      totalRules: this.testRules.length,
+      attributes
+    }));
+    if (!this.testRules.length) {
+      debug2("[Pack Test LocalResolver] No test rules available");
+      return null;
+    }
+    const eligibleTests = await this.evaluateRules(this.testRules, attributes);
+    debug2("[Pack Test LocalResolver] Rule evaluation result:", JSON.stringify({
+      totalTests: this.testRules.length,
+      eligibleTests: eligibleTests.length,
+      eligibleTestIds: eligibleTests.map((t) => ({ id: t.id, handle: t.handle }))
+    }));
+    if (!eligibleTests.length) {
+      debug2("[Pack Test LocalResolver] No eligible tests found");
+      return null;
+    }
+    const randomTestIndex = this.getRandomNumber(eligibleTests.length - 1);
+    const selectedTest = eligibleTests[randomTestIndex];
+    debug2("[Pack Test LocalResolver] Selected test:", JSON.stringify({
+      testId: selectedTest.id,
+      testHandle: selectedTest.handle,
+      randomIndex: randomTestIndex,
+      totalEligible: eligibleTests.length
+    }));
+    const randomPercentage = this.getRandomNumber(100, 1);
+    let accumulatedPercentage = 0;
+    debug2("[Pack Test LocalResolver] Starting variant assignment:", JSON.stringify({
+      randomPercentage,
+      variants: selectedTest.testVariants.map((v) => ({
+        id: v.id,
+        handle: v.handle,
+        trafficPercentage: v.trafficPercentage
+      }))
+    }));
+    for (const variant of selectedTest.testVariants) {
+      accumulatedPercentage += variant.trafficPercentage * 100;
+      debug2("[Pack Test LocalResolver] Checking variant:", JSON.stringify({
+        variantId: variant.id,
+        variantHandle: variant.handle,
+        trafficPercentage: variant.trafficPercentage,
+        accumulatedPercentage,
+        randomPercentage,
+        isSelected: accumulatedPercentage >= randomPercentage
+      }));
+      if (accumulatedPercentage >= randomPercentage) {
+        const result = {
+          id: selectedTest.id,
+          handle: selectedTest.handle,
+          testVariant: {
+            id: variant.id,
+            handle: variant.handle
+          }
+        };
+        debug2("[Pack Test LocalResolver] Variant selected:", JSON.stringify(result));
+        return result;
+      }
+    }
+    debug2("[Pack Test LocalResolver] No variant selected (should not happen)");
+    return null;
+  }
+  /**
+   * Evaluate rules using json-rules-engine (same as tests-service)
+   */
+  async evaluateRules(tests, attributes) {
+    debug2("[Pack Test LocalResolver] Starting rule evaluation:", JSON.stringify({
+      totalTests: tests.length,
+      attributes,
+      isClientSide: typeof window !== "undefined"
+    }));
+    if (typeof window !== "undefined") {
+      debug2("[Pack Test LocalResolver] Client side - returning all tests");
+      return tests;
+    }
+    const engineResultsPromises = tests.map((test, index) => {
+      const { rules } = test;
+      debug2(`[Pack Test LocalResolver] Processing test ${index}:`, JSON.stringify({
+        testId: test.id,
+        testHandle: test.handle,
+        rulesCount: rules?.length || 0,
+        rules
+      }));
+      if (rules && Array.isArray(rules)) {
+        if (rules.length === 0) {
+          debug2(`[Pack Test LocalResolver] Test ${test.handle} has no rules - targeting all`);
+          return Promise.resolve({
+            events: [{ type: "targeted" }]
+          });
+        } else {
+          const engineConditionalProperties = rules.filter(
+            (rule) => rule !== null && typeof rule === "object" && Object.hasOwn(rule, "attribute") && Object.hasOwn(rule, "operator") && Object.hasOwn(rule, "value")
+          ).map((rule) => ({
+            fact: rule.attribute,
+            operator: rule.operator,
+            value: rule.value
+          }));
+          debug2(`[Pack Test LocalResolver] Test ${test.handle} engine conditions:`, JSON.stringify(engineConditionalProperties));
+          const engineRules = [
+            new import_json_rules_engine.Rule({
+              conditions: {
+                all: engineConditionalProperties
+              },
+              event: {
+                type: "targeted"
+              }
+            })
+          ];
+          const engine = new import_json_rules_engine.Engine(engineRules, {
+            allowUndefinedFacts: true
+          });
+          engine.addOperator(
+            "stringContains",
+            (factValue, jsonValue) => {
+              return !!factValue && factValue.includes(jsonValue);
+            }
+          );
+          engine.addOperator(
+            "stringDoesNotContain",
+            (factValue, jsonValue) => {
+              return !!factValue && !factValue.includes(jsonValue);
+            }
+          );
+          engine.addOperator(
+            "matchesRegex",
+            (factValue, jsonValue) => {
+              return !!factValue && new RegExp(jsonValue).test(factValue);
+            }
+          );
+          engine.addOperator(
+            "doesNotMatchRegex",
+            (factValue, jsonValue) => {
+              return !!factValue && !new RegExp(jsonValue).test(factValue);
+            }
+          );
+          engine.addOperator(
+            "isSet",
+            (factValue) => !!factValue
+          );
+          engine.addOperator(
+            "isNotSet",
+            (factValue) => !factValue
+          );
+          const result = engine.run(attributes);
+          debug2(`[Pack Test LocalResolver] Engine result for test ${test.handle}:`, JSON.stringify(result));
+          return result;
+        }
+      }
+      debug2(`[Pack Test LocalResolver] Test ${test.handle} has invalid rules`);
+      return void 0;
+    });
+    const engineResults = await Promise.all(engineResultsPromises);
+    debug2("[Pack Test LocalResolver] All engine results:", JSON.stringify(engineResults));
+    const eligibleTests = tests.filter(
+      (test, index) => {
+        const hasTargetedEvent = !!engineResults?.[index]?.events.find((event) => event.type === "targeted");
+        debug2(`[Pack Test LocalResolver] Test ${test.handle} eligibility:`, JSON.stringify({
+          hasTargetedEvent,
+          events: engineResults?.[index]?.events
+        }));
+        return hasTargetedEvent;
+      }
+    );
+    debug2("[Pack Test LocalResolver] Final eligible tests:", JSON.stringify({
+      eligibleCount: eligibleTests.length,
+      eligibleTests: eligibleTests.map((t) => ({ id: t.id, handle: t.handle }))
+    }));
+    return eligibleTests;
   }
-  commit() {
-    this.#isDirty = false;
-    this.#initialData = {
-      test_data: this.getTestData(),
-      test_expire_at: this.getExpireAt()
+  /**
+   * Resolve test and variant IDs from their handles
+   */
+  resolveTestIdsFromHandles(testHandle, variantHandle) {
+    const test = this.testRules.find((t) => t.handle === testHandle);
+    if (!test) {
+      return null;
+    }
+    const variant = test.testVariants?.find((v) => v.handle === variantHandle);
+    if (!variant) {
+      return null;
+    }
+    return {
+      testId: test.id,
+      variantId: variant.id
     };
-    return this.#sessionStorage.commitSession(this.#session);
-  }
-  destroy() {
-    this.#isDirty = true;
-    this.#session.unset("test_data");
-    this.#session.unset("test_expire_at");
-    return this.#sessionStorage.destroySession(this.#session);
   }
 };
 
-// src/create-pack-client.ts
-var import_cookie4 = __toESM(require_cookie());
-import { PackClient } from "@pack/client";
-import { CacheCustom, createWithCache } from "@shopify/hydrogen";
-
 // src/tests/test.ts
-var import_cookie3 = __toESM(require_cookie());
-var QUERY_TEST_VARIANT_IS_RUNNING = `#graphql
-  query TestVariantIsRunning($handle: String!, $testId: ID!) {
-    testVariantIsRunning(handle: $handle, testId: $testId)
+var import_debug3 = __toESM(require_browser(), 1);
+var debug3 = (0, import_debug3.default)("pack:ab-testing:test");
+var QUERY_TESTS_BY_RULES = `#graphql
+  query TestsByRules($status: String) {
+    testsByRulesV2(status: $status) {
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      edges {
+        cursor
+        node {
+          id
+          handle
+          rules {
+            attribute
+            operator
+            value
+          }
+          testVariants {
+            id
+            handle
+            trafficPercentage
+          }
+        }
+      }
+    }
   }
 `;
-async function packClientFetchTestByRules(packClient, testTargetAudienceAttributes, token) {
-  if (!packClient.storeId) {
-    console.error("Pack error: Store ID is required to fetch a test.");
-    return void 0;
+var localTestResolver = new LocalTestResolver();
+function generateTestRulesCacheKey(storeId, contentEnvironment) {
+  return `pack-tests:${storeId}:${contentEnvironment || "default"}`;
+}
+async function fetchTestRulesShared(packClient, withCache, token) {
+  const baseCacheKey = generateTestRulesCacheKey(
+    packClient.storeId || "",
+    packClient.contentEnvironment
+  );
+  debug3(
+    "[Pack Test] Fetching test rules with shared cache:",
+    JSON.stringify({
+      baseCacheKey,
+      storeId: packClient.storeId,
+      contentEnvironment: packClient.contentEnvironment
+    })
+  );
+  let testsUpdatedAt;
+  try {
+    const resp = await withCache.run(
+      {
+        cacheKey: ["pack:tests:updatedAt"],
+        cacheStrategy: {
+          maxAge: 15,
+          staleWhileRevalidate: 15
+        },
+        shouldCacheResult: (value) => value !== null
+      },
+      async ({
+        addDebugData
+      }) => {
+        const URL2 = process.env.NODE_ENV === "development" ? "http://localhost:8787/tests-updated-at" : "https://test-cache-check-production.packdigital.workers.dev/tests-updated-at";
+        debug3("[Pack Test] Fetching timestamp from:", URL2);
+        const resp2 = await fetch(URL2, {
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        });
+        addDebugData?.({
+          displayName: "Pack Test Cache Check",
+          response: resp2
+        });
+        const { status } = resp2;
+        if (status !== 200) {
+          let message;
+          if (status === 401) {
+            message = "Pack error: Unauthorized request to test cache check service. Please check your token.";
+          } else {
+            message = `Pack error: Request to test cache check service failed with status ${status}`;
+          }
+          debug3(`[Pack Test] Cache check error: ${message}`);
+          console.error(message);
+          return null;
+        }
+        const data = await resp2.json();
+        debug3("[Pack Test] Timestamp response:", JSON.stringify(data));
+        return data;
+      }
+    );
+    testsUpdatedAt = resp?.testsUpdatedAt;
+    debug3(
+      "[Pack Test] Using timestamp for cache key:",
+      JSON.stringify({
+        testsUpdatedAt,
+        hasTimestamp: !!testsUpdatedAt
+      })
+    );
+  } catch (err) {
+    debug3(
+      "[Pack Test] Error checking test cache timestamp:",
+      JSON.stringify(err)
+    );
+    console.error("[Pack Test] Error checking test cache timestamp:", err);
   }
-  let resp = void 0;
-  const URL2 = "https://tests-service-production.packdigital.workers.dev/tests/assign";
-  const assignByRulesResp = await fetch(URL2, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "X-Pack-Storefront-Id": packClient.storeId,
-      ...packClient.contentEnvironment ? { "X-Environment": packClient.contentEnvironment } : {},
-      "Content-Type": "application/json"
+  const cacheKey = testsUpdatedAt ? `${baseCacheKey}:${testsUpdatedAt}` : baseCacheKey;
+  debug3("[Pack Test] Final cache key for test rules:", cacheKey);
+  return withCache.run(
+    {
+      cacheKey: [cacheKey],
+      cacheStrategy: {
+        maxAge: 3600,
+        // 1 hour
+        staleWhileRevalidate: 86400,
+        // 24 hours
+        staleIfError: 86400
+        // 24 hours
+      },
+      shouldCacheResult: (result) => Array.isArray(result) && result.length >= 0,
+      displayName: "Pack Test Rules"
     },
-    body: JSON.stringify({
-      attributes: testTargetAudienceAttributes
-    })
-  });
-  const { status } = assignByRulesResp;
-  if (status !== 200) {
-    let message;
-    if (status === 401) {
-      message = "Pack error: Unauthorized request to test assignment service. Please check your token.";
-    } else {
-      message = `Pack error: Request to test assignment service failed with status ${status}`;
+    async ({ addDebugData }) => {
+      const startTime = Date.now();
+      debug3(
+        "[Pack Test] Cache miss - fetching test rules from Pack GraphQL API"
+      );
+      try {
+        const { data, error } = await packClient.fetch(QUERY_TESTS_BY_RULES, {
+          variables: { status: "running" }
+        });
+        const fetchDuration = Date.now() - startTime;
+        debug3(
+          "[Pack Test] GraphQL query completed:",
+          JSON.stringify({
+            duration: `${fetchDuration}ms`,
+            hasData: !!data,
+            hasError: !!error,
+            totalCount: data?.testsByRulesV2?.totalCount,
+            edgesCount: data?.testsByRulesV2?.edges?.length || 0
+          })
+        );
+        addDebugData?.({
+          displayName: "Pack Test Rules Query"
+        });
+        if (error) {
+          debug3(
+            "[Pack Test] Error fetching test rules:",
+            JSON.stringify({
+              error,
+              errorType: typeof error,
+              errorMessage: error?.message || JSON.stringify(error)
+            })
+          );
+          throw new Error(`GraphQL error: ${JSON.stringify(error)}`);
+        }
+        const rules = data?.testsByRulesV2?.edges.map((edge) => edge.node) || [];
+        debug3(
+          "[Pack Test] Successfully fetched and cached test rules:",
+          JSON.stringify({
+            rulesCount: rules.length,
+            cacheKey,
+            rules: rules.map((rule) => ({
+              id: rule.id,
+              handle: rule.handle,
+              rulesCount: rule.rules?.length || 0,
+              variantsCount: rule.testVariants?.length || 0
+            }))
+          })
+        );
+        return rules;
+      } catch (error) {
+        const fetchDuration = Date.now() - startTime;
+        debug3(
+          "[Pack Test] Exception fetching test rules:",
+          JSON.stringify({
+            error: error instanceof Error ? error.message : error,
+            duration: `${fetchDuration}ms`,
+            stack: error instanceof Error ? error.stack : void 0
+          })
+        );
+        throw error;
+      }
     }
-    console.error(message);
-    return resp;
-  }
-  const assignByRulesRespJson = await assignByRulesResp.json();
-  if (assignByRulesRespJson?.data) {
-    resp = {
-      ...assignByRulesRespJson.data,
-      // `isFirstExposure` tells the `<PackTestRoute />` this will be the
-      // first exposure on render and will be confirmed next request
-      isFirstExposure: true
-    };
-  }
-  return resp;
+  );
 }
-async function packClientCheckTestIsRunning(packClient, testSession) {
+async function packClientFetchTestByRules(packClient, testTargetAudienceAttributes, testSession, request, withCache, token, exposedTest, validateOnly) {
   try {
-    const resp = await packClient.fetch(QUERY_TEST_VARIANT_IS_RUNNING, {
-      variables: {
-        handle: testSession.testVariant.handle,
-        testId: testSession.id
+    debug3(
+      "[Pack Test] Starting test assignment process:",
+      JSON.stringify({
+        storeId: packClient.storeId,
+        targetingAttributes: testTargetAudienceAttributes,
+        requestUrl: request.url,
+        validateOnly
+      })
+    );
+    if (!packClient.storeId) {
+      debug3("[Pack Test] Store ID is required to fetch a test.");
+      console.error("[Pack Test] Store ID is required to fetch a test.");
+      return void 0;
+    }
+    debug3(
+      "[Pack Test] Checking if rules are loaded:",
+      JSON.stringify({
+        hasRules: localTestResolver.hasRules()
+      })
+    );
+    if (withCache && token) {
+      debug3("[Pack Test] Fetching test rules through shared cache");
+      try {
+        const rules = await fetchTestRulesShared(
+          packClient,
+          withCache,
+          token
+        );
+        localTestResolver.setTestRules(rules);
+        debug3(
+          "[Pack Test] Updated local resolver with rules from shared cache"
+        );
+        const currentTestData = testSession.getTestData();
+        let needsNewTest = false;
+        if (currentTestData?.id) {
+          const freshTestData = localTestResolver.getTestById(currentTestData.id);
+          if (!freshTestData) {
+            debug3(
+              "[Pack Test] Current session test is no longer active (paused/stopped), clearing session:",
+              JSON.stringify({
+                testId: currentTestData.id,
+                testHandle: currentTestData.handle
+              })
+            );
+            testSession.clearTestData();
+            needsNewTest = true;
+          } else {
+            debug3(
+              "[Pack Test] Current session test is still active in rules, updating with fresh data:",
+              JSON.stringify({
+                testId: freshTestData.id,
+                testHandle: freshTestData.handle,
+                variantsCount: freshTestData.testVariants?.length
+              })
+            );
+            if (currentTestData.testVariant?.id) {
+              const currentVariant = freshTestData.testVariants?.find(
+                (v) => v.id === currentTestData.testVariant.id
+              );
+              if (currentVariant) {
+                const refreshedTest = {
+                  id: freshTestData.id,
+                  handle: freshTestData.handle,
+                  testVariant: {
+                    id: currentVariant.id,
+                    handle: currentVariant.handle
+                  },
+                  isFirstExposure: void 0
+                };
+                const { isFirstExposure: isFirstExposure2, ...testDataWithoutFlag2 } = refreshedTest;
+                testSession.setTestData(testDataWithoutFlag2);
+                testSession.setExpireAt(getExpireAtDate().toISOString());
+                return refreshedTest;
+              } else {
+                debug3(
+                  "[Pack Test] Current variant no longer exists in test, clearing session:",
+                  JSON.stringify({
+                    testId: currentTestData.id,
+                    variantId: currentTestData.testVariant.id
+                  })
+                );
+                testSession.clearTestData();
+                needsNewTest = true;
+              }
+            }
+          }
+        }
+        if (validateOnly && !needsNewTest) {
+          debug3("[Pack Test] Validation complete, no new test needed");
+          return void 0;
+        }
+      } catch (error) {
+        debug3(
+          "[Pack Test] Failed to fetch test rules:",
+          JSON.stringify(error)
+        );
+        console.error("[Pack Test] Failed to fetch test rules:", error);
       }
-    });
-    return !!resp.data.testVariantIsRunning;
-  } catch (e) {
-    console.error(e);
+    } else {
+      debug3(
+        "[Pack Test] No withCache or token available - cannot fetch test rules"
+      );
+    }
+    if (exposedTest) {
+      const freshTestData = localTestResolver.getTestById(exposedTest.id);
+      if (freshTestData) {
+        debug3(
+          "[Pack Test] Exposed test is still active in rules, restoring with fresh data:",
+          JSON.stringify({
+            testId: freshTestData.id,
+            testHandle: freshTestData.handle
+          })
+        );
+        const exposedVariant = freshTestData.testVariants?.find(
+          (v) => v.id === exposedTest.testVariant?.id
+        );
+        if (exposedVariant) {
+          const result2 = {
+            id: freshTestData.id,
+            handle: freshTestData.handle,
+            testVariant: {
+              id: exposedVariant.id,
+              handle: exposedVariant.handle
+            },
+            isFirstExposure: void 0
+          };
+          const { isFirstExposure: isFirstExposure2, ...testDataWithoutFlag2 } = result2;
+          testSession.setTestData(testDataWithoutFlag2);
+          testSession.setExpireAt(getExpireAtDate().toISOString());
+          return result2;
+        } else {
+          debug3(
+            "[Pack Test] Exposed test variant no longer exists in fresh data:",
+            JSON.stringify({
+              testId: exposedTest.id,
+              variantId: exposedTest.testVariant?.id
+            })
+          );
+        }
+      } else {
+        debug3(
+          "[Pack Test] Exposed test is no longer active in rules:",
+          JSON.stringify({
+            testId: exposedTest.id
+          })
+        );
+      }
+    }
+    const sessionId = packClient.storeId;
+    debug3("[Pack Test] Assigning test with session ID:", sessionId);
+    const assignedTest = await localTestResolver.assignTest(
+      testTargetAudienceAttributes || {},
+      sessionId
+    );
+    debug3(
+      "[Pack Test] Test assignment result:",
+      JSON.stringify({
+        assigned: !!assignedTest,
+        testId: assignedTest?.id,
+        testHandle: assignedTest?.handle,
+        variantId: assignedTest?.testVariant?.id,
+        variantHandle: assignedTest?.testVariant?.handle
+      })
+    );
+    if (!assignedTest) {
+      debug3(
+        "[Pack Test] No test assigned - user not eligible for any tests"
+      );
+      return void 0;
+    }
+    const result = {
+      ...assignedTest,
+      isFirstExposure: true
+    };
+    debug3(
+      "[Pack Test] Test assigned, saving to session:",
+      JSON.stringify({
+        testId: result.id,
+        testHandle: result.handle,
+        variantId: result.testVariant.id,
+        variantHandle: result.testVariant.handle
+      })
+    );
+    const { isFirstExposure, ...testDataWithoutFlag } = result;
+    testSession.setTestData(testDataWithoutFlag);
+    testSession.setExpireAt(getExpireAtDate().toISOString());
+    debug3("[Pack Test] Returning test info with first exposure flag");
+    return result;
+  } catch (error) {
+    debug3(
+      "[Pack Test] Error in packClientFetchTestByRules, continuing without test:",
+      JSON.stringify(error)
+    );
+    console.error(
+      "[Pack Test] Error in packClientFetchTestByRules, continuing without test:",
+      error
+    );
+    return void 0;
   }
-  return false;
 }
 function getExpireAtDate() {
   const expireAt = /* @__PURE__ */ new Date();
@@ -2083,82 +5634,257 @@ async function getTestInfo({
   testTargetAudienceAttributes,
   packClient,
   testSession,
+  withCache,
   token
 }) {
+  debug3(
+    "[Pack Test] Getting test info:",
+    JSON.stringify({
+      hasTestSession: !!testSession,
+      targetingAttributes: testTargetAudienceAttributes,
+      requestUrl: request.url
+    })
+  );
   let testInfo = void 0;
   let exposedTest = void 0;
   if (!testSession) {
+    debug3("[Pack Test] No test session available, returning undefined");
     return testInfo;
   }
   const testSessionData = testSession.getTestData();
   const testSessionExpireAt = testSession.getExpireAt();
-  const exposedTestCookieString = import_cookie3.default.parse(
+  debug3(
+    "[Pack Test] Session data check:",
+    JSON.stringify({
+      hasTestData: !!testSessionData,
+      testId: testSessionData?.id,
+      testHandle: testSessionData?.handle,
+      variantId: testSessionData?.testVariant?.id,
+      variantHandle: testSessionData?.testVariant?.handle,
+      expireAt: testSessionExpireAt,
+      isExpired: testSessionExpireAt ? new Date(testSessionExpireAt) < /* @__PURE__ */ new Date() : false
+    })
+  );
+  const exposedTestCookieString = cookie2.parse(
     request.headers.get("cookie") || ""
   )?.exposedTest;
+  debug3(
+    "[Pack Test] Exposed test cookie check:",
+    JSON.stringify({
+      hasExposedTestCookie: !!exposedTestCookieString
+    })
+  );
   if (testSessionData?.id && testSessionData?.testVariant) {
+    debug3("[Pack Test] Found existing test data in session");
     if (!testSessionExpireAt || new Date(testSessionExpireAt) >= /* @__PURE__ */ new Date()) {
+      debug3(
+        "[Pack Test] Test session not expired by time, fetching rules to validate if test is still active"
+      );
       try {
-        const testStillRunning = await packClientCheckTestIsRunning(
+        const validationResult = await packClientFetchTestByRules(
           packClient,
-          testSessionData
+          testTargetAudienceAttributes,
+          testSession,
+          request,
+          withCache,
+          token,
+          null,
+          true
+          // validateOnly - but will assign new test if current is inactive
         );
-        if (testStillRunning) {
-          return testSessionData;
+        if (validationResult) {
+          if (validationResult.id === testSessionData.id) {
+            debug3(
+              "[Pack Test] Test is still active, using refreshed data",
+              JSON.stringify({
+                testId: validationResult.id,
+                testHandle: validationResult.handle,
+                variantId: validationResult.testVariant.id,
+                variantHandle: validationResult.testVariant.handle
+              })
+            );
+            return validationResult;
+          } else {
+            debug3(
+              "[Pack Test] Original test no longer active, new test assigned",
+              JSON.stringify({
+                oldTestId: testSessionData.id,
+                newTestId: validationResult.id,
+                newTestHandle: validationResult.handle,
+                newVariantId: validationResult.testVariant.id,
+                newVariantHandle: validationResult.testVariant.handle
+              })
+            );
+            return {
+              ...validationResult,
+              isFirstExposure: true
+            };
+          }
+        } else {
+          debug3("[Pack Test] Test is no longer active and no new test was assigned");
+          return void 0;
         }
       } catch (error) {
+        debug3(
+          "[Pack Test] Error validating test, using cached data:",
+          JSON.stringify(error)
+        );
         console.error(
-          "Error checking if test is running, using cached data",
+          "[Pack Test] Error validating test, using cached data:",
           error
         );
-        return testSessionData;
+        return { ...testSessionData, isFirstExposure: void 0 };
       }
+    } else {
+      debug3("[Pack Test] Test session has expired by time");
+      debug3("[Pack Test] Clearing expired test session data");
+      testSession.clearTestData();
     }
-    testSession.clearTestData();
   }
   if (exposedTestCookieString) {
-    exposedTest = JSON.parse(exposedTestCookieString);
+    try {
+      exposedTest = JSON.parse(exposedTestCookieString);
+      debug3(
+        "[Pack Test] Parsed exposed test from cookie:",
+        JSON.stringify({
+          testId: exposedTest?.id,
+          testHandle: exposedTest?.handle,
+          variantId: exposedTest?.testVariant?.id,
+          variantHandle: exposedTest?.testVariant?.handle
+        })
+      );
+    } catch (error) {
+      debug3(
+        "[Pack Test] Failed to parse exposed test cookie:",
+        JSON.stringify(error)
+      );
+      console.error("[Pack Test] Failed to parse exposed test cookie:", error);
+    }
   }
   if (exposedTest && !testSessionData) {
-    const testVariantIsRunning = await packClientCheckTestIsRunning(
-      packClient,
-      exposedTest
+    debug3(
+      "[Pack Test] Found exposed test cookie with no session data - will fetch rules and validate"
     );
-    if (testVariantIsRunning) {
-      const { id, handle, testVariant } = exposedTest;
-      testInfo = {
-        id,
-        handle,
-        testVariant
-      };
-      testSession.setTestData(testInfo);
-      testSession.setExpireAt(getExpireAtDate().toISOString());
-    } else {
-      testSession.clearTestData();
+    try {
       testInfo = await packClientFetchTestByRules(
         packClient,
         testTargetAudienceAttributes,
-        token
+        testSession,
+        request,
+        withCache,
+        token,
+        exposedTest,
+        false
+        // Not validateOnly - allow assigning new tests
+      );
+      if (testInfo?.id === exposedTest.id) {
+        debug3(
+          "[Pack Test] Exposed test was restored (still active)"
+        );
+      } else if (testInfo) {
+        debug3(
+          "[Pack Test] Exposed test is no longer active, using newly assigned test:",
+          JSON.stringify({
+            exposedTestId: exposedTest.id,
+            newTestId: testInfo.id
+          })
+        );
+      } else {
+        debug3(
+          "[Pack Test] Exposed test is no longer active and no new test was assigned"
+        );
+      }
+    } catch (error) {
+      debug3(
+        "[Pack Test] Error processing exposed test:",
+        JSON.stringify(error)
+      );
+      console.error(
+        "[Pack Test] Error processing exposed test, continuing without test:",
+        error
       );
+      testInfo = void 0;
     }
   } else if (testSessionData) {
-    testSession.clearTestData();
-    testInfo = await packClientFetchTestByRules(
-      packClient,
-      testTargetAudienceAttributes,
-      token
+    debug3(
+      "[Pack Test] Test session data exists but was invalid - fetching new test"
     );
+    testSession.clearTestData();
+    try {
+      testInfo = await packClientFetchTestByRules(
+        packClient,
+        testTargetAudienceAttributes,
+        testSession,
+        request,
+        withCache,
+        token,
+        null,
+        false
+        // Not validateOnly - allow assigning new tests
+      );
+    } catch (error) {
+      debug3(
+        "[Pack Test] Error fetching new test after expired session:",
+        JSON.stringify(error)
+      );
+      console.error(
+        "[Pack Test] Error fetching new test, continuing without test:",
+        error
+      );
+      testInfo = void 0;
+    }
   } else {
-    testInfo = await packClientFetchTestByRules(
-      packClient,
-      testTargetAudienceAttributes,
-      token
+    debug3(
+      "[Pack Test] No existing test data found - fetching new test for user"
     );
+    try {
+      testInfo = await packClientFetchTestByRules(
+        packClient,
+        testTargetAudienceAttributes,
+        testSession,
+        request,
+        withCache,
+        token,
+        null,
+        false
+        // Not validateOnly - allow assigning new tests
+      );
+    } catch (error) {
+      debug3(
+        "[Pack Test] Error fetching new test for user:",
+        JSON.stringify(error)
+      );
+      console.error(
+        "[Pack Test] Error fetching new test, continuing without test:",
+        error
+      );
+      testInfo = void 0;
+    }
   }
+  debug3(
+    "[Pack Test] Final test info result:",
+    JSON.stringify({
+      hasTestInfo: !!testInfo,
+      testId: testInfo?.id,
+      testHandle: testInfo?.handle,
+      variantId: testInfo?.testVariant?.id,
+      variantHandle: testInfo?.testVariant?.handle,
+      isFirstExposure: testInfo?.isFirstExposure
+    })
+  );
   return testInfo;
 }
 function getTestSession(testSession, testFromQueryParams = null, previewEnabled = false) {
+  debug3(
+    "[Pack Test] Getting test session:",
+    JSON.stringify({
+      hasTestSession: !!testSession,
+      hasQueryParams: !!testFromQueryParams,
+      previewEnabled
+    })
+  );
   if (testFromQueryParams) {
-    return {
+    const result = {
       id: testFromQueryParams.testId || "",
       handle: testFromQueryParams.testHandle || "",
       testVariant: {
@@ -2166,9 +5892,14 @@ function getTestSession(testSession, testFromQueryParams = null, previewEnabled
         handle: testFromQueryParams.testVariantHandle || ""
       }
     };
+    debug3(
+      "[Pack Test] Using test from query parameters:",
+      JSON.stringify(result)
+    );
+    return result;
   }
   if (previewEnabled) {
-    return {
+    const result = {
       id: "",
       handle: "isPreview",
       testVariant: {
@@ -2176,11 +5907,27 @@ function getTestSession(testSession, testFromQueryParams = null, previewEnabled
         handle: "isPreview"
       }
     };
+    debug3(
+      "[Pack Test] Using preview mode test session:",
+      JSON.stringify(result)
+    );
+    return result;
   }
   if (!testSession) {
+    debug3("[Pack Test] No test session available");
     return void 0;
   }
   const testSessionData = testSession.getTestData();
+  debug3(
+    "[Pack Test] Retrieved test session data:",
+    JSON.stringify({
+      hasData: !!testSessionData,
+      testId: testSessionData?.id,
+      testHandle: testSessionData?.handle,
+      variantId: testSessionData?.testVariant?.id,
+      variantHandle: testSessionData?.testVariant?.handle
+    })
+  );
   return testSessionData || null;
 }
 function getTestTargetingAttributesFromRequest(request) {
@@ -2211,7 +5958,7 @@ function getTestFromQueryParams(request) {
   return null;
 }
 function setTestHeaders(headers, options) {
-  const { previewEnabled, testFromQueryParams, testInfoForRequest } = options;
+  const { testFromQueryParams, testInfoForRequest } = options;
   if (testFromQueryParams) {
     headers["X-Pack-Test-Ignore-Test-Status"] = true;
     if (testFromQueryParams.testId) {
@@ -2227,25 +5974,25 @@ function setTestHeaders(headers, options) {
       headers["X-Pack-Test-Variant-Handle"] = testFromQueryParams.testVariantHandle;
     }
   } else if (testInfoForRequest) {
-    headers = {
-      "X-Pack-Test-Id": testInfoForRequest?.id,
-      "X-Pack-Test-Variant-Id": testInfoForRequest?.testVariant?.id
-    };
+    headers["X-Pack-Test-Id"] = testInfoForRequest?.id;
+    headers["X-Pack-Test-Variant-Id"] = testInfoForRequest?.testVariant?.id;
   }
   return headers;
 }
 
 // src/create-pack-client.ts
+var import_debug4 = __toESM(require_browser(), 1);
+var debug4 = (0, import_debug4.default)("pack:ab-testing:create-pack-client");
 async function sha2562(message) {
   const messageBuffer = new TextEncoder().encode(message);
   const hashBuffer = await crypto.subtle.digest("SHA-256", messageBuffer);
   return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function hashQuery(query, variables, headers) {
-  let hash = query;
-  if (variables !== null) hash += JSON.stringify(variables);
-  if (headers !== null) hash += JSON.stringify(headers);
-  return sha2562(hash);
+  let hash2 = query;
+  if (variables !== null) hash2 += JSON.stringify(variables);
+  if (headers !== null) hash2 += JSON.stringify(headers);
+  return sha2562(hash2);
 }
 async function getCacheKey(withCache, query, token, options) {
   let queryHash = await hashQuery(query, options?.variables, options?.headers);
@@ -2277,6 +6024,7 @@ async function getCacheKey(withCache, query, token, options) {
           } else {
             message = `Pack error: Request to cache check service failed with status ${status}`;
           }
+          debug4(`Cache check error: ${message}`);
           console.error(message);
           return null;
         }
@@ -2285,6 +6033,7 @@ async function getCacheKey(withCache, query, token, options) {
     );
     publishedAt = resp?.publishedAt;
   } catch (err) {
+    debug4(`Error getting cache key: ${err}`);
     console.error(err);
   }
   if (publishedAt) {
@@ -2330,14 +6079,17 @@ function createPackClient(options) {
     storeId,
     token,
     apiUrl,
-    defaultThemeData
+    defaultThemeData,
+    request
   } = options;
   const previewEnabled = !!session.get("previewEnabled");
   const previewEnvironment = session.get("environment");
   const clientContentEnvironment = previewEnvironment || contentEnvironment;
   let packClient;
-  let testFromQueryParams = null;
   let testInfoForRequest = void 0;
+  let testInfoPromise = void 0;
+  let currentRequest = request;
+  let testFromQueryParams = request ? getTestFromQueryParams(request) : null;
   if (!token && !defaultThemeData) {
     throw new Error(
       "ERR_HY_MISSING_TOKEN: The Pack client token is missing or empty. Please provide a valid token or default theme data. Doc: https://docs.packdigital.com/err/ERR_HY_MISSING_TOKEN"
@@ -2348,25 +6100,17 @@ function createPackClient(options) {
       "ERR_HY_MISSING_STORE_ID: The Pack Store ID is missing or empty. Please provide a valid Store ID. Doc: https://docs.packdigital.com/err/ERR_HY_MISSING_STORE_ID"
     );
   }
-  const handleRequest2 = async (request) => {
-    testFromQueryParams = getTestFromQueryParams(request);
-    const testTargetAudienceAttributes = getTestTargetingAttributesFromRequest(request);
-    if (packClient && token) {
-      testInfoForRequest = await getTestInfo({
-        request,
-        testTargetAudienceAttributes,
-        packClient,
-        testSession,
-        // Use dedicated test session instead
-        token
-      });
+  const handleRequest2 = async (request2) => {
+    if (!currentRequest) {
+      currentRequest = request2;
+      testFromQueryParams = getTestFromQueryParams(request2);
     }
     return (response) => {
-      const hasExposedTestCookie = request.headers.get("cookie")?.includes("exposedTest");
+      const hasExposedTestCookie = request2.headers.get("cookie")?.includes("exposedTest");
       if (hasExposedTestCookie) {
         response.headers.append(
           "Set-Cookie",
-          import_cookie4.default.serialize("exposedTest", "", {
+          cookie3.serialize("exposedTest", "", {
             maxAge: 0,
             expires: /* @__PURE__ */ new Date(0),
             path: "/"
@@ -2375,17 +6119,11 @@ function createPackClient(options) {
       }
     };
   };
-  const getTestInfoForLoader = () => {
-    let testInfoForLoader = void 0;
-    if (testInfoForRequest?.isFirstExposure) {
-      const { isFirstExposure, ...testInfo } = testInfoForRequest;
-      testInfoForLoader = testInfo;
-    }
-    return testInfoForLoader;
-  };
   if (!token) {
     return {
-      abTest: getTestSession(testSession, testFromQueryParams, previewEnabled),
+      get abTest() {
+        return getTestSession(testSession, testFromQueryParams, previewEnabled);
+      },
       handleRequest: handleRequest2,
       getPackSessionData: () => {
         return {
@@ -2415,27 +6153,25 @@ function createPackClient(options) {
       },
       isPreviewModeEnabled: () => previewEnabled,
       isValidEditToken: () => new Promise(() => false),
-      async query(query, options2) {
+      async query(query, { variables } = {}) {
         if (!defaultThemeData?.data) {
+          debug4("Warning: Invalid default theme data provided to Pack client");
           console.warn("Invalid default theme data provided to Pack client.");
           return { data: null, error: null };
         }
-        const data = resolveQuery({
-          query,
-          variables: options2.variables,
-          defaultThemeData
-        });
+        const data = resolveQuery({ query, variables, defaultThemeData });
         return { data, error: null };
       },
       session,
       testSession
     };
   }
+  const resolvedApiUrl = apiUrl ? apiUrl : previewEnabled || process.env.NODE_ENV === "development" ? "https://app.packdigital.com/graphql" : void 0;
   packClient = new PackClient({
     // Use apiUrl, it is configured
     // Use active API URL if preview mode is enabled
     // Otherwise, Live PackClient uses its internal configuration
-    apiUrl: apiUrl ? apiUrl : previewEnabled || process.env.NODE_ENV === "development" ? "https://app.packdigital.com/graphql" : void 0,
+    apiUrl: resolvedApiUrl,
     storeId,
     token,
     contentEnvironment: clientContentEnvironment,
@@ -2443,7 +6179,9 @@ function createPackClient(options) {
     clientName: "HydrogenClient"
   });
   return {
-    abTest: getTestSession(testSession, testFromQueryParams, previewEnabled),
+    get abTest() {
+      return getTestSession(testSession, testFromQueryParams, previewEnabled);
+    },
     getPackSessionData: () => {
       return {
         storeId,
@@ -2473,72 +6211,121 @@ function createPackClient(options) {
     handleRequest: handleRequest2,
     isPreviewModeEnabled: () => previewEnabled,
     isValidEditToken: (token2) => packClient.isValidEditToken(token2),
-    async query(query, options2) {
-      let headers = {};
-      headers = setTestHeaders(headers, {
-        previewEnabled,
-        testInfoForRequest,
-        testFromQueryParams: testFromQueryParams || options2.test
-      });
-      if (previewEnabled) {
-        const queryVariables2 = options2.variables ? { ...options2.variables } : {};
-        queryVariables2.version = "CURRENT";
-        const testInfoForLoader2 = getTestInfoForLoader();
-        try {
-          return {
-            ...await packClient.fetch(query, {
-              variables: queryVariables2,
-              headers
-            }),
-            packTestInfo: testInfoForLoader2
-          };
-        } catch (error) {
-          return { error, data: null };
+    async query(query, { variables, cache: strategy = cacheCustom, test } = {}) {
+      try {
+        let headers = {};
+        let testInfoForLoader = void 0;
+        const withCache = createWithCache({
+          cache,
+          waitUntil,
+          request: new Request("https://pack.local/cache", { method: "GET" })
+        });
+        const queryVariables = variables ? { ...variables } : {};
+        if (previewEnabled) {
+          queryVariables.version = "CURRENT";
+        } else {
+          queryVariables.version = "PUBLISHED";
         }
-      }
-      const withCache = createWithCache({
-        cache,
-        waitUntil,
-        request: options2.request
-      });
-      headers = setTestHeaders(headers, {
-        previewEnabled,
-        testInfoForRequest,
-        testFromQueryParams: testFromQueryParams || options2.test
-      });
-      const queryVariables = options2.variables ? { ...options2.variables } : {};
-      if (previewEnabled) {
-        queryVariables.version = "CURRENT";
-      } else {
-        queryVariables.version = "PUBLISHED";
-      }
-      const testInfoForLoader = getTestInfoForLoader();
-      const queryHash = await getCacheKey(withCache, query, token, {
-        variables: queryVariables,
-        headers
-      });
-      const response = await withCache.run(
-        {
-          cacheKey: [queryHash],
-          cacheStrategy: options2.cache || cacheCustom,
-          shouldCacheResult: (value) => !value?.error
-        },
-        async ({ addDebugData }) => {
+        if (packClient && token && !testInfoForRequest && currentRequest) {
+          try {
+            if (!testInfoPromise) {
+              debug4(
+                "[Pack Test] Creating getTestInfo promise - first query for this request"
+              );
+              testInfoPromise = getTestInfo({
+                request: currentRequest,
+                testTargetAudienceAttributes: getTestTargetingAttributesFromRequest(currentRequest),
+                packClient,
+                testSession,
+                // Use dedicated test session instead
+                withCache,
+                token
+              });
+            } else {
+              debug4(
+                "[Pack Test] Reusing existing getTestInfo promise - concurrent query"
+              );
+            }
+            testInfoForRequest = await testInfoPromise;
+          } catch (error) {
+            debug4(
+              "[Pack Test] Error getting test info, continuing without test:",
+              error
+            );
+            console.error(
+              "[Pack Test] Error getting test info, continuing without test:",
+              error
+            );
+            testInfoForRequest = void 0;
+            testInfoPromise = void 0;
+          }
+        } else if (packClient && token && testInfoForRequest) {
+          debug4("[Pack Test] Using cached testInfo - subsequent query");
+          if (process.env.NODE_ENV === "development") {
+            console.log("[Pack Test] Using cached testInfo - subsequent query");
+          }
+        }
+        if (testInfoForRequest?.isFirstExposure) {
+          const { isFirstExposure, ...testInfo } = testInfoForRequest;
+          testInfoForLoader = testInfo;
+        }
+        headers = setTestHeaders(headers, {
+          previewEnabled,
+          testInfoForRequest,
+          testFromQueryParams: testFromQueryParams || test
+        });
+        if (previewEnabled) {
           try {
             const result = await packClient.fetch(query, {
               variables: queryVariables,
               headers
             });
-            addDebugData?.({
-              displayName: "Pack GraphQL Query"
-            });
-            return result;
+            return {
+              ...result,
+              packTestInfo: testInfoForLoader
+            };
           } catch (error) {
             return { error, data: null };
           }
         }
-      );
-      return response.error ? response : { ...response, packTestInfo: testInfoForLoader };
+        const queryHash = await getCacheKey(withCache, query, token, {
+          variables: queryVariables,
+          headers
+        });
+        const response = await withCache.run(
+          {
+            cacheKey: [queryHash],
+            cacheStrategy: strategy,
+            shouldCacheResult: (value) => !value?.error
+          },
+          async () => {
+            try {
+              const result = await packClient.fetch(query, {
+                variables: queryVariables,
+                headers
+              });
+              return result;
+            } catch (error) {
+              return { error, data: null };
+            }
+          }
+        );
+        return response.error ? response : { ...response, packTestInfo: testInfoForLoader };
+      } catch (error) {
+        debug4(
+          "[Pack Test] Critical error in query method, returning error:",
+          error
+        );
+        console.error(
+          "[Pack Test] Critical error in query method, returning error:",
+          error
+        );
+        const queryError = {
+          message: error instanceof Error ? error.message : String(error),
+          type: "NetworkError"
+        };
+        return { error: queryError, data: null };
+      }
     },
     session,
     testSession
@@ -2743,16 +6530,26 @@ var usePackTestContext = () => useContext(PackTestContext);
 // src/tests/pack-test-route.ts
 var usePackLoaderData = () => {
   const [exposedTestInfo, setExposedTestInfo] = useState();
-  const { packTestInfo } = useLoaderData();
-  const [root] = useMatches();
-  const { packIsPreviewMode } = root?.data;
+  let packTestInfo;
+  let packIsPreviewMode;
+  let revalidator;
+  try {
+    const loaderData = useLoaderData();
+    packTestInfo = loaderData?.packTestInfo;
+    const [root] = useMatches();
+    packIsPreviewMode = root?.data?.packIsPreviewMode;
+    revalidator = useRevalidator();
+  } catch (error) {
+    packTestInfo = void 0;
+    packIsPreviewMode = void 0;
+    revalidator = void 0;
+  }
   const {
     testExposureCallback,
     hasUserConsent: hasUserConsent2,
     pendingExposureQueue,
     setPendingExposureQueue
   } = usePackTestContext();
-  const revalidator = useRevalidator();
   const exposedTestCookieString = api.get("exposedTest");
   useEffect2(() => {
     if (packTestInfo && !packIsPreviewMode && !hasUserConsent2 && exposedTestCookieString && exposedTestInfo) {
@@ -2780,7 +6577,6 @@ var usePackLoaderData = () => {
         expires
       });
       setExposedTestInfo(packTestInfo);
-      console.log("=== TCB HAS USER CONSENT", hasUserConsent2);
       pendingExposureQueue?.forEach((data, key) => {
         try {
           testExposureCallback?.({
@@ -2797,7 +6593,7 @@ var usePackLoaderData = () => {
         }
       });
       testExposureCallback?.({ ...packTestInfo, exposureTime: Date.now() });
-      revalidator.revalidate();
+      revalidator?.revalidate();
     }
   }, [packTestInfo, testExposureCallback, exposedTestInfo, hasUserConsent2]);
 };
@@ -2897,6 +6693,27 @@ cookie/index.js:
    * MIT Licensed
    *)
 
+curry2/index.js:
+  (*!
+   * imports.
+   *)
+  (*!
+   * exports.
+   *)
+
+brackets2dots/index.js:
+  (*!
+   * exports.
+   *)
+  (*!
+   * regexp patterns.
+   *)
+
+dotsplit.js/index.js:
+  (*!
+   * exports.
+   *)
+
 js-cookie/dist/js.cookie.mjs:
   (*! js-cookie v3.0.5 | MIT *)
 */