@uniformdev/next-app-router 20.74.6-alpha.6 → 20.74.6-alpha.7.sha-23d7a1d929

package/dist/index.esm.js

@@ -390,6 +390,195 @@ var require_retry2 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "../../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports, module) {
+    "use strict";
+    module.exports = rfdc4;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc4(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone2(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone2);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone2);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone2);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone2(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
 // src/index.ts
 import "server-only";
 
@@ -1446,15 +1635,15 @@ var CanvasClient = class extends ApiClient {
   /** Updates or creates a Canvas component definition */
   async updateComposition(body, options) {
     const fetchUri = this.createUrl(CANVAS_URL2);
-    const headers = {};
+    const headers2 = {};
     if (options == null ? void 0 : options.ifUnmodifiedSince) {
-      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+      headers2["x-if-unmodified-since"] = options.ifUnmodifiedSince;
     }
     const { response } = await this.apiClientWithResponse(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
       expectNoContent: true,
-      headers
+      headers: headers2
     });
     return { modified: response.headers.get("x-modified-at") };
   }
@@ -1552,15 +1741,15 @@ var _ContentClient = class _ContentClient2 extends ApiClient {
   }
   async upsertEntry(body, options) {
     const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _entriesUrl));
-    const headers = {};
+    const headers2 = {};
     if (options == null ? void 0 : options.ifUnmodifiedSince) {
-      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+      headers2["x-if-unmodified-since"] = options.ifUnmodifiedSince;
     }
     const { response } = await this.apiClientWithResponse(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
       expectNoContent: true,
-      headers
+      headers: headers2
     });
     return { modified: response.headers.get("x-modified-at") };
   }
@@ -1871,7 +2060,8 @@ function walkNodeTree(node, visitor, options) {
               "_dataResources",
               "_overridability",
               "_overrides",
-              "_patternDataResources"
+              "_patternDataResources",
+              "_patternOptedInQueryStrings"
             ];
             propertiesToCheck.forEach((property) => {
               if (!replacementComponent[property]) {
@@ -2057,7 +2247,155 @@ var BlockFormatError = class _BlockFormatError extends Error {
 function createVariableReference(variableName) {
   return `\${${variableName.replace(/([${}])/g, "\\$1")}}`;
 }
+function evaluateVisibilityCriteriaGroup(options) {
+  const { criteriaGroup, simplifyCriteria } = options;
+  const earlyExitResult = criteriaGroup.op === "&" || !criteriaGroup.op ? false : true;
+  let hasIndeterminateClauses = false;
+  for (let index = criteriaGroup.clauses.length - 1; index >= 0; index--) {
+    const clause = criteriaGroup.clauses[index];
+    const criteriaResult = evaluateCriterion(clause, options);
+    if (criteriaResult === null) {
+      hasIndeterminateClauses = true;
+    } else if (criteriaResult === earlyExitResult) {
+      return earlyExitResult;
+    } else if (criteriaResult !== null && simplifyCriteria) {
+      criteriaGroup.clauses.splice(index, 1);
+    }
+  }
+  return hasIndeterminateClauses ? null : !earlyExitResult;
+}
+function evaluateCriterion(clause, rootOptions) {
+  var _a;
+  if ("clauses" in clause) {
+    return evaluateVisibilityCriteriaGroup({
+      ...rootOptions,
+      criteriaGroup: clause
+    });
+  }
+  const lhs = (_a = clause.source) != null ? _a : clause.rule;
+  const rhs = Array.isArray(clause.value) ? clause.value : clause.value !== void 0 ? [clause.value] : void 0;
+  if (typeof lhs === "string" && hasReferencedVariables(lhs) > 0 || (rhs == null ? void 0 : rhs.some((rhv) => typeof rhv === "string" && hasReferencedVariables(rhv) > 0))) {
+    return null;
+  }
+  const rule = rootOptions.rules[clause.rule];
+  if (rule) {
+    return rule(clause);
+  }
+  return null;
+}
+function evaluateNodeVisibilityParameter({
+  parameter,
+  ...evaluateGroupOptions
+}) {
+  if (parameter == null ? void 0 : parameter.explicitlyHidden) {
+    return false;
+  }
+  if (!(parameter == null ? void 0 : parameter.criteria)) {
+    return true;
+  }
+  const result = evaluateVisibilityCriteriaGroup({
+    ...evaluateGroupOptions,
+    criteriaGroup: parameter.criteria
+  });
+  return result;
+}
 var CANVAS_VIZ_CONTROL_PARAM = "$viz";
+var isEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.includes(matchValue);
+  }
+  return criteria === matchValue;
+};
+var containsEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.includes(criterion));
+  }
+  return matchValue.includes(criteria);
+};
+var startsWithEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.startsWith(criterion));
+  }
+  return matchValue.startsWith(criteria);
+};
+var endsWithEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.endsWith(criterion));
+  }
+  return matchValue.endsWith(criteria);
+};
+var emptyEvaluator = (_, matchValue) => {
+  return matchValue === "";
+};
+var stringOperatorEvaluators = {
+  is: isEvaluator,
+  has: containsEvaluator,
+  startswith: startsWithEvaluator,
+  endswith: endsWithEvaluator,
+  empty: emptyEvaluator
+};
+var numericOperatorEvaluators = {
+  gt: (left, right) => left > right,
+  lt: (left, right) => left < right
+};
+function evaluateNumericOperator(criteria, matchValue) {
+  const { op, value } = criteria;
+  const evaluator = numericOperatorEvaluators[op];
+  if (!evaluator) {
+    return null;
+  }
+  if (typeof matchValue === "string" && matchValue.trim() === "" || typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  const leftNum = Number(matchValue);
+  const rightNum = Number(value);
+  if (isNaN(leftNum) || isNaN(rightNum)) {
+    return false;
+  }
+  return evaluator(leftNum, rightNum);
+}
+function evaluateStringMatch(criteria, matchValue, allow) {
+  const { op, value } = criteria;
+  if (allow && !allow.has(op)) {
+    return null;
+  }
+  if (op in numericOperatorEvaluators) {
+    return evaluateNumericOperator(criteria, matchValue);
+  }
+  let opMatch = op;
+  const negation = op.startsWith("!");
+  if (negation) {
+    opMatch = opMatch.slice(1);
+  }
+  const evaluator = stringOperatorEvaluators[opMatch];
+  if (!evaluator) {
+    return null;
+  }
+  const result = evaluator(value, matchValue);
+  return negation ? !result : result;
+}
+var quirksVisibilityOperators = /* @__PURE__ */ new Set([
+  "is",
+  "!is",
+  "has",
+  "!has",
+  "startswith",
+  "!startswith",
+  "endswith",
+  "!endswith",
+  "empty",
+  "!empty"
+]);
+var CANVAS_VIZ_QUIRKS_RULE = "$qk";
+function createQuirksVisibilityRule(quirks) {
+  return {
+    [CANVAS_VIZ_QUIRKS_RULE]: (criterion) => {
+      const { source } = criterion;
+      const quirkValue = source ? quirks[source] : void 0;
+      return evaluateStringMatch(criterion, quirkValue != null ? quirkValue : "", quirksVisibilityOperators);
+    }
+  };
+}
 var _baseUrl;
 var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends ApiClient {
   constructor(options) {
@@ -2501,7 +2839,7 @@ var buildCanvasClientOptions = (options) => {
     limitPolicy: createLimitPolicy2({
       limit: 6
     }),
-    fetch: (req, init) => {
+    fetch: (req, init2) => {
       let requestedUrl;
       if (typeof req === "string") {
         requestedUrl = new URL(req);
@@ -2528,10 +2866,10 @@ var buildCanvasClientOptions = (options) => {
       }
       const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
       return fetch(req, {
-        ...init,
+        ...init2,
         cache: fetchCache,
         headers: {
-          ...init == null ? void 0 : init.headers,
+          ...init2 == null ? void 0 : init2.headers,
           "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
         },
         next: {
@@ -2580,12 +2918,12 @@ var getManifestClient = (options) => {
     limitPolicy: createLimitPolicy2({
       limit: 6
     }),
-    fetch: (req, init) => {
+    fetch: (req, init2) => {
       const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
       return fetch(req, {
-        ...init,
+        ...init2,
         headers: {
-          ...init == null ? void 0 : init.headers,
+          ...init2 == null ? void 0 : init2.headers,
           "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
         },
         cache: fetchCache,
@@ -2922,12 +3260,12 @@ var getProjectMapClient = (options) => {
     limitPolicy: createLimitPolicy2({
       limit: 6
     }),
-    fetch: (req, init) => {
+    fetch: (req, init2) => {
       const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
       return fetch(req, {
-        ...init,
+        ...init2,
         headers: {
-          ...init == null ? void 0 : init.headers,
+          ...init2 == null ? void 0 : init2.headers,
           "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
         },
         cache: fetchCache,
@@ -2963,7 +3301,7 @@ var getRouteClient = (options) => {
     limitPolicy: createLimitPolicy2({
       limit: 6
     }),
-    fetch: (req, init) => {
+    fetch: (req, init2) => {
       let requestedUrl;
       if (typeof req === "string") {
         requestedUrl = new URL(req);
@@ -2975,9 +3313,9 @@ var getRouteClient = (options) => {
       const tags = getRouteCacheTags(requestedUrl);
       const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
       return fetch(req, {
-        ...init,
+        ...init2,
         headers: {
-          ...init == null ? void 0 : init.headers,
+          ...init2 == null ? void 0 : init2.headers,
           "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
         },
         cache: fetchCache,
@@ -2998,115 +3336,2836 @@ import {
   resolveRuleFromPageState
 } from "@uniformdev/next-app-router-shared";
 import { notFound } from "next/navigation";
-import React5, { createElement as createElement2, Fragment as Fragment3, Suspense as Suspense2 } from "react";
+import React4, { createElement as createElement2, Fragment as Fragment2, Suspense } from "react";
 
-// src/data/extract/extractTest.ts
-import { extractTestName } from "@uniformdev/next-app-router-shared";
-var extractTest = ({ component }) => {
-  var _a;
-  const testName = extractTestName({ component });
-  const slot = ((_a = component.slots) == null ? void 0 : _a[CANVAS_TEST_SLOT]) || [];
-  const componentVariations = mapSlotToTestVariations(slot).map((variation, index) => {
-    const slotComponent = slot[index];
-    if (!slotComponent) {
-      throw new Error(`Slot component not found for index ${index}`);
+// src/data/evaluate/evaluateDraftPageState.ts
+import { cookies, headers } from "next/headers";
+
+// ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function dequal(foo, bar) {
+  var ctor, len;
+  if (foo === bar) return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len])) ;
+      }
+      return len === -1;
     }
-    return {
-      ...variation,
-      index,
-      componentId: slotComponent._id
-    };
-  });
-  return {
-    name: testName,
-    variations: componentVariations
-  };
-};
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
 
-// src/components/ComponentProps.ts
-import {
-  resolveComponentFromPageState
-} from "@uniformdev/next-app-router-shared";
-var createComponentProps = ({
-  component,
-  parent,
-  isRoot,
-  slotName,
-  slotIndex,
-  slots,
-  pageState,
-  composition,
-  compositionContext
-}) => {
-  var _a, _b;
-  const parameters = (_a = component.parameters) != null ? _a : {};
-  const componentProps = {
-    parameters: Object.keys(parameters).reduce((acc, cur) => {
-      acc[cur] = {
-        parameterId: cur,
-        ...parameters[cur]
-      };
-      return acc;
-    }, {}),
-    component: {
-      _id: component._id,
-      _parentId: (_b = parent == null ? void 0 : parent._id) != null ? _b : null,
-      slotName,
-      slotIndex: isRoot ? void 0 : slotIndex
-    },
-    type: component.type,
-    variant: component.variant,
-    slots,
-    context: {
-      isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
-      _id: composition._id,
-      state: pageState.compositionState,
-      type: composition.type,
-      pageState,
-      matchedRoute: compositionContext.matchedRoute,
-      dynamicInputs: compositionContext.dynamicInputs
+// ../../node_modules/.pnpm/js-cookie@3.0.8/node_modules/js-cookie/dist/js.cookie.mjs
+function assign(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      if (key === "__proto__") continue;
+      target[key] = source[key];
     }
-  };
-  return componentProps;
+  }
+  return target;
+}
+var defaultConverter = {
+  read: function(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
 };
-var createPersonalizeComponentProps = ({
-  common,
-  componentId,
-  pageState
-}) => {
-  var _a;
-  const component = resolveComponentFromPageState({
-    pageState,
-    componentId
-  });
-  return {
-    ...common,
-    indexes: (_a = component == null ? void 0 : component.indexes) != null ? _a : []
-  };
+function init(converter, defaultAttributes) {
+  function set(name, value, attributes) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    attributes = assign({}, defaultAttributes, attributes);
+    if (typeof attributes.expires === "number") {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+    name = encodeURIComponent(name).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue;
+      }
+      stringifiedAttributes += "; " + attributeName;
+      if (attributes[attributeName] === true) {
+        continue;
+      }
+      stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+    }
+    return document.cookie = name + "=" + converter.write(value, name) + stringifiedAttributes;
+  }
+  function get(name) {
+    if (typeof document === "undefined" || arguments.length && !name) {
+      return;
+    }
+    var cookies2 = document.cookie ? document.cookie.split("; ") : [];
+    var jar = {};
+    for (var i = 0; i < cookies2.length; i++) {
+      var parts = cookies2[i].split("=");
+      var value = parts.slice(1).join("=");
+      try {
+        var found = decodeURIComponent(parts[0]);
+        if (!(found in jar)) jar[found] = converter.read(value, found);
+        if (name === found) {
+          break;
+        }
+      } catch (_e) {
+      }
+    }
+    return name ? jar[name] : jar;
+  }
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function(name, attributes) {
+        set(
+          name,
+          "",
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes));
+      },
+      withConverter: function(converter2) {
+        return init(assign({}, this.converter, converter2), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  );
+}
+var api = init(defaultConverter, { path: "/" });
+
+// ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// ../context/dist/index.mjs
+var import_rfdc = __toESM(require_rfdc(), 1);
+var import_rfdc2 = __toESM(require_rfdc(), 1);
+var import_rfdc3 = __toESM(require_rfdc(), 1);
+var __defProp3 = Object.defineProperty;
+var __typeError5 = (msg) => {
+  throw TypeError(msg);
 };
-var createTestComponentProps = ({
-  common,
-  componentId,
-  pageState,
-  test
-}) => {
+var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck5 = (obj, member, msg) => member.has(obj) || __typeError5("Cannot " + msg);
+var __privateGet5 = (obj, member, getter) => (__accessCheck5(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd5 = (obj, member, value) => member.has(obj) ? __typeError5("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet3 = (obj, member, value, setter) => (__accessCheck5(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod2 = (obj, member, method) => (__accessCheck5(obj, member, "access private method"), method);
+function computeAggregateDimensions(primitiveScores, aggregates) {
+  const result = { ...primitiveScores };
+  for (const aggregateDimension in aggregates) {
+    const aggregateScore = computeAggregateDimension(
+      primitiveScores,
+      aggregateDimension,
+      aggregates,
+      /* @__PURE__ */ new Set([aggregateDimension])
+    );
+    if (aggregateScore !== 0) {
+      result[aggregateDimension] = aggregateScore;
+    }
+  }
+  return result;
+}
+function computeAggregateDimension(primitiveScores, aggregateDimension, allAggregates, visitedDimensions) {
   var _a;
-  if (pageState.isPrefetch) {
+  let aggregateScore = 0;
+  for (const input of allAggregates[aggregateDimension].inputs) {
+    let currentScore = (_a = primitiveScores[input.dim]) != null ? _a : 0;
+    if (!currentScore) {
+      const aggRef = allAggregates[input.dim];
+      if (aggRef) {
+        if (visitedDimensions.has(input.dim)) {
+          continue;
+        }
+        const newVisited = new Set(visitedDimensions);
+        newVisited.add(input.dim);
+        currentScore = computeAggregateDimension(primitiveScores, input.dim, allAggregates, newVisited);
+      }
+    }
+    if (currentScore !== 0) {
+      if (input.sign === "c") {
+        aggregateScore = 0;
+        break;
+      } else if (input.sign === "-") {
+        aggregateScore -= currentScore;
+      } else {
+        aggregateScore += currentScore;
+      }
+    }
+  }
+  return aggregateScore;
+}
+var ENR_SEPARATOR = "_";
+var _id;
+var SignalGoalEvaluator = class {
+  constructor(options) {
+    __privateAdd5(this, _id);
+    __privateSet3(this, _id, options.id);
+  }
+  get id() {
+    return __privateGet5(this, _id);
+  }
+  evaluate({ scores, quirks }) {
+    const score = scores == null ? void 0 : scores[__privateGet5(this, _id)];
+    const key = `goal_${__privateGet5(this, _id)}_triggered`;
+    const hasGoalTriggered = (quirks == null ? void 0 : quirks[key]) === "1";
     return {
-      ...common,
-      index: void 0,
-      test
+      key,
+      triggered: typeof score === "number" && !hasGoalTriggered
     };
   }
-  const component = resolveComponentFromPageState({
-    pageState,
-    componentId
-  });
-  const [testIndex] = (_a = component == null ? void 0 : component.indexes) != null ? _a : [];
-  return {
-    ...common,
-    index: testIndex,
-    test
+};
+_id = /* @__PURE__ */ new WeakMap();
+var _evaluator;
+var _onLogMessage;
+var SignalInstance = class {
+  constructor(data, evaluator, onLogMessage) {
+    __privateAdd5(this, _evaluator);
+    __privateAdd5(this, _onLogMessage);
+    __publicField3(this, "signal");
+    this.signal = data;
+    __privateSet3(this, _evaluator, evaluator);
+    __privateSet3(this, _onLogMessage, onLogMessage);
+  }
+  /** Computes storage update commands to take based on a state update and the signal's criteria */
+  computeSignal(update, commands) {
+    const isAtCap = update.scores[this.signal.id] >= this.signal.cap;
+    if (isAtCap && this.signal.dur !== "t") {
+      return;
+    }
+    const criteriaMatchUpdate = __privateGet5(this, _evaluator).evaluate(
+      update,
+      this.signal.crit,
+      commands,
+      this.signal,
+      __privateGet5(this, _onLogMessage)
+    );
+    const scoreCommand = this.signal.dur === "s" || this.signal.dur === "t" ? "modscoreS" : "modscore";
+    if (!criteriaMatchUpdate.changed) {
+      return;
+    }
+    if (criteriaMatchUpdate.result) {
+      commands.push({
+        type: scoreCommand,
+        data: { dimension: this.signal.id, delta: this.signal.str }
+      });
+    } else if (this.signal.dur === "t") {
+      const sessionScore = update.visitor.sessionScores[this.signal.id];
+      if (sessionScore) {
+        commands.push({
+          type: scoreCommand,
+          data: { dimension: this.signal.id, delta: -sessionScore }
+        });
+      }
+    }
+  }
+};
+_evaluator = /* @__PURE__ */ new WeakMap();
+_onLogMessage = /* @__PURE__ */ new WeakMap();
+var rollForControlGroup = (value) => {
+  let control = value;
+  if (control >= 1) {
+    control = control / 100;
+  }
+  return Math.random() < control;
+};
+var _mf;
+var _signalInstances;
+var _goalEvaluators;
+var _onLogMessage2;
+var ManifestInstance = class {
+  constructor({
+    manifest,
+    evaluator = new GroupCriteriaEvaluator({}),
+    onLogMessage = () => {
+    }
+  }) {
+    __publicField3(this, "data");
+    __privateAdd5(this, _mf);
+    __privateAdd5(this, _signalInstances);
+    __privateAdd5(this, _goalEvaluators, []);
+    __privateAdd5(this, _onLogMessage2);
+    var _a, _b, _c, _d, _e;
+    __privateSet3(this, _mf, (_a = manifest.project) != null ? _a : {});
+    this.data = manifest;
+    __privateSet3(this, _signalInstances, Object.entries((_c = (_b = __privateGet5(this, _mf).pz) == null ? void 0 : _b.sig) != null ? _c : []).map(
+      ([id, signal]) => new SignalInstance({ ...signal, id }, evaluator, onLogMessage)
+    ));
+    Object.entries((_e = (_d = __privateGet5(this, _mf).pz) == null ? void 0 : _d.sig) != null ? _e : []).forEach(([id, signal]) => {
+      if (signal.conversion) {
+        __privateGet5(this, _goalEvaluators).push(new SignalGoalEvaluator({ id, signal }));
+      }
+    });
+    __privateSet3(this, _onLogMessage2, onLogMessage);
+  }
+  rollForControlGroup() {
+    var _a;
+    return rollForControlGroup(((_a = __privateGet5(this, _mf).pz) == null ? void 0 : _a.control) || 0);
+  }
+  getTest(name) {
+    var _a;
+    return (_a = __privateGet5(this, _mf).test) == null ? void 0 : _a[name];
+  }
+  computeSignals(update) {
+    const commands = [];
+    __privateGet5(this, _onLogMessage2).call(this, ["debug", 200, "GROUP"]);
+    try {
+      __privateGet5(this, _signalInstances).forEach((signal) => {
+        __privateGet5(this, _onLogMessage2).call(this, ["debug", 201, "GROUP", signal.signal]);
+        try {
+          signal.computeSignal(update, commands);
+        } finally {
+          __privateGet5(this, _onLogMessage2).call(this, ["debug", 201, "ENDGROUP"]);
+        }
+      });
+    } finally {
+      __privateGet5(this, _onLogMessage2).call(this, ["debug", 200, "ENDGROUP"]);
+    }
+    return commands;
+  }
+  computeGoals(data) {
+    const commands = [];
+    __privateGet5(this, _goalEvaluators).forEach((evaluator) => {
+      const { triggered, key } = evaluator.evaluate(data);
+      if (triggered) {
+        commands.push({
+          type: "setgoal",
+          data: {
+            goal: evaluator.id
+          }
+        });
+        commands.push({
+          type: "setquirk",
+          data: {
+            key,
+            value: "1"
+          }
+        });
+      }
+    });
+    return commands;
+  }
+  /**
+   * Computes aggregated scores based on other dimensions
+   */
+  computeAggregateDimensions(primitiveScores) {
+    var _a, _b;
+    return computeAggregateDimensions(primitiveScores, (_b = (_a = __privateGet5(this, _mf).pz) == null ? void 0 : _a.agg) != null ? _b : {});
+  }
+  getDimensionByKey(scoreKey) {
+    var _a, _b, _c, _d;
+    const enrichmentIndex = scoreKey.indexOf(ENR_SEPARATOR);
+    if (enrichmentIndex <= 0) {
+      return (_b = (_a = __privateGet5(this, _mf).pz) == null ? void 0 : _a.sig) == null ? void 0 : _b[scoreKey];
+    }
+    return (_d = (_c = __privateGet5(this, _mf).pz) == null ? void 0 : _c.enr) == null ? void 0 : _d[scoreKey.substring(0, enrichmentIndex)];
+  }
+  getAggregateDimensionByKey(scoreKey) {
+    var _a, _b;
+    return (_b = (_a = __privateGet5(this, _mf).pz) == null ? void 0 : _a.agg) == null ? void 0 : _b[scoreKey];
+  }
+};
+_mf = /* @__PURE__ */ new WeakMap();
+_signalInstances = /* @__PURE__ */ new WeakMap();
+_goalEvaluators = /* @__PURE__ */ new WeakMap();
+_onLogMessage2 = /* @__PURE__ */ new WeakMap();
+function isStringMatch(lhs, match) {
+  var _a, _b, _c, _d, _e, _f;
+  const type = (_a = match == null ? void 0 : match.op) != null ? _a : "=";
+  if (match.op === "*") {
+    return lhs !== null && typeof lhs !== "undefined";
+  }
+  if (match.op === "!*") {
+    return lhs === null || typeof lhs === "undefined";
+  }
+  if (!("rhs" in match)) {
+    throw new Error(`Match expression is required for match type ${type}`);
+  }
+  const caseSensitive = (_b = match.cs) != null ? _b : false;
+  const localRhs = (caseSensitive ? lhs != null ? lhs : "" : caseDesensitize(lhs)).toString();
+  const localLhs = (caseSensitive ? match.rhs : caseDesensitize(match.rhs)).toString();
+  switch (type) {
+    case "=":
+      return localRhs === localLhs;
+    case "!=":
+      return localRhs !== localLhs;
+    case "~":
+      return (_c = localRhs.includes(localLhs)) != null ? _c : false;
+    case "!~":
+      return !((_d = localRhs.includes(localLhs)) != null ? _d : true);
+    case "//":
+      return new RegExp(match.rhs.toString(), caseSensitive ? "" : "i").test((_e = lhs == null ? void 0 : lhs.toString()) != null ? _e : "");
+    case "!//":
+      return !new RegExp(match.rhs.toString(), caseSensitive ? "" : "i").test((_f = lhs == null ? void 0 : lhs.toString()) != null ? _f : "");
+    default:
+      throw new Error(`Unknown match type ${type}.`);
+  }
+}
+function explainStringMatch(lhs, match) {
+  const cs = "cs" in match ? match.cs : false;
+  return `'${cs ? lhs : lhs == null ? void 0 : lhs.toString().toUpperCase()}' ${explainStringMatchCriteria(match)}`;
+}
+function explainStringMatchCriteria(match) {
+  if ("rhs" in match) {
+    return `${match.op} '${match.cs ? match.rhs : match.rhs.toString().toUpperCase()}'`;
+  }
+  return `${match.op === "*" ? "exists" : "does not exist"}`;
+}
+function caseDesensitize(value) {
+  var _a, _b;
+  return (_b = (_a = value == null ? void 0 : value.toString()) == null ? void 0 : _a.toUpperCase()) != null ? _b : "";
+}
+var cookieEvaluator = ({ update, criteria, onLogMessage }) => {
+  var _a, _b;
+  if (criteria.type !== "CK") {
+    return { result: false, changed: false };
+  }
+  const changed = !dequal(cleanCookies(update.state.cookies), cleanCookies((_a = update.previousState) == null ? void 0 : _a.cookies));
+  const value = (_b = update.state.cookies) == null ? void 0 : _b[criteria.cookieName];
+  const result = isStringMatch(value, criteria.match);
+  const finalResult = { result, changed };
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainStringMatch(value, criteria.match) }
+  ]);
+  return finalResult;
+};
+function cleanCookies(cookie) {
+  if (!cookie) {
+    return void 0;
+  }
+  if (!cookie.ufvd) {
+    return cookie;
+  }
+  const { ufvd, ...rest } = cookie;
+  return rest;
+}
+var currentPageEvaluator = ({ update, criteria, onLogMessage }) => {
+  var _a, _b, _c;
+  if (criteria.type !== "PV") {
+    return { result: false, changed: false };
+  }
+  const value = (_a = update.state.url) == null ? void 0 : _a.pathname;
+  const hasUrlChanged = !update.previousState || (value == null ? void 0 : value.toString()) !== ((_c = (_b = update.previousState.url) == null ? void 0 : _b.pathname) == null ? void 0 : _c.toString());
+  const result = isStringMatch(value, criteria.path);
+  const finalResult = { result, changed: hasUrlChanged };
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainStringMatch(value, criteria.path) }
+  ]);
+  return finalResult;
+};
+var eventEvaluator = ({ update, criteria, onLogMessage }) => {
+  var _a, _b, _c;
+  if (criteria.type !== "EVT") {
+    return { result: false, changed: false };
+  }
+  const result = (_b = (_a = update.state.events) == null ? void 0 : _a.some((event) => isStringMatch(event.event, criteria.event))) != null ? _b : false;
+  const finalResult = { result, changed: result };
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    {
+      criteria,
+      result: finalResult,
+      explanation: `'${(_c = update.state.events) == null ? void 0 : _c.join("', '")}' ${explainStringMatchCriteria(criteria.event)}`
+    }
+  ]);
+  return finalResult;
+};
+function getEnrichmentVectorKey(category, value) {
+  return `${category}${ENR_SEPARATOR}${value}`;
+}
+function isNumberMatch(lhs, match) {
+  var _a;
+  if (typeof lhs === "undefined" || lhs === null) {
+    return false;
+  }
+  const lhsValue = Number(lhs);
+  if (isNaN(lhsValue)) {
+    return false;
+  }
+  switch ((_a = match == null ? void 0 : match.op) != null ? _a : "=") {
+    case "=":
+      return lhsValue === match.rhs;
+    case "!=":
+      return lhsValue !== match.rhs;
+    case ">":
+      return lhsValue > match.rhs;
+    case "<":
+      return lhsValue < match.rhs;
+    default:
+      console.warn(`Unknown match type ${match.op} is false.`);
+      return false;
+  }
+}
+function explainNumberMatch(lhs, match) {
+  return `${lhs} ${explainNumberMatchCriteria(match)}`;
+}
+function explainNumberMatchCriteria(match) {
+  return `${match.op} ${match.rhs}`;
+}
+var pageViewCountDimension = getEnrichmentVectorKey("$pvc", "v");
+var pageViewCountEvaluator = ({ update, criteria, commands, onLogMessage }) => {
+  var _a, _b;
+  if (criteria.type !== "PVC") {
+    return { result: false, changed: false };
+  }
+  const hasUrlChanged = Boolean(
+    update.state.url && (!update.previousState || ((_a = update.state.url) == null ? void 0 : _a.toString()) !== ((_b = update.previousState.url) == null ? void 0 : _b.toString()))
+  );
+  const existingValueNumber = update.visitor.sessionScores[pageViewCountDimension] || 0;
+  const updatedCount = existingValueNumber + 1;
+  const finalResult = { result: false, changed: hasUrlChanged };
+  const hasExistingPageViewIncrementCommand = commands.some(
+    (c) => c.type === "modscoreS" && c.data.dimension === pageViewCountDimension
+  );
+  if (hasUrlChanged && !hasExistingPageViewIncrementCommand) {
+    commands.push({
+      type: "modscoreS",
+      data: {
+        dimension: pageViewCountDimension,
+        delta: 1
+      }
+    });
+  }
+  if (isNumberMatch(updatedCount, criteria.match)) {
+    finalResult.result = true;
+  }
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainNumberMatch(updatedCount, criteria.match) }
+  ]);
+  return finalResult;
+};
+pageViewCountEvaluator.alwaysExecute = true;
+var queryStringEvaluator = ({ update, criteria, onLogMessage }) => {
+  var _a, _b, _c, _d, _e;
+  if (criteria.type !== "QS") {
+    return { result: false, changed: false };
+  }
+  const hasQueryChanged = !update.previousState || ((_b = (_a = update.state.url) == null ? void 0 : _a.searchParams) == null ? void 0 : _b.toString()) !== ((_d = (_c = update.previousState.url) == null ? void 0 : _c.searchParams) == null ? void 0 : _d.toString());
+  const value = (_e = update.state.url) == null ? void 0 : _e.searchParams.get(criteria.queryName);
+  const result = isStringMatch(value, criteria.match);
+  const finalResult = { result, changed: hasQueryChanged };
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainStringMatch(value, criteria.match) }
+  ]);
+  return finalResult;
+};
+var quirkEvaluator = ({ update, criteria, signal, onLogMessage }) => {
+  var _a;
+  if (criteria.type !== "QK") {
+    return { result: false, changed: false };
+  }
+  if (typeof document === "undefined" && update.scores[signal.id] > 0) {
+    return { result: true, changed: false };
+  }
+  const visitorValue = update.visitor.quirks[criteria.key];
+  const updateValue = (_a = update.state.quirks) == null ? void 0 : _a[criteria.key];
+  const value = updateValue != null ? updateValue : visitorValue;
+  const changed = Boolean(updateValue !== void 0 && visitorValue !== updateValue);
+  const result = isStringMatch(value, criteria.match);
+  const finalResult = { result, changed };
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainStringMatch(value, criteria.match) }
+  ]);
+  return finalResult;
+};
+var _evaluators;
+var GroupCriteriaEvaluator = class {
+  constructor(criteriaEvaluators) {
+    __privateAdd5(this, _evaluators);
+    __privateSet3(this, _evaluators, criteriaEvaluators);
+  }
+  evaluate(update, crit, commands, signal, onLogMessage) {
+    const hasMultipleClauses = crit.clauses.length > 1;
+    if (hasMultipleClauses) {
+      onLogMessage == null ? void 0 : onLogMessage(["debug", 202, "GROUP", crit]);
+    }
+    try {
+      const earlyExitEvaluatorResult = crit.op === "&" || !crit.op ? false : true;
+      let earlyExitResult = null;
+      let isAnyChanged = false;
+      for (const criteria of crit.clauses) {
+        let result;
+        if (criteria.type === "G") {
+          result = this.evaluate(update, criteria, commands, signal, onLogMessage);
+        } else {
+          const evaluator = __privateGet5(this, _evaluators)[criteria.type];
+          if (earlyExitResult && !evaluator.alwaysExecute) {
+            continue;
+          }
+          if (!evaluator) {
+            throw new Error(`${criteria.type} signal criteria not registered`);
+          }
+          result = evaluator({ update, criteria, commands, signal, onLogMessage });
+        }
+        if (result.changed) {
+          isAnyChanged = true;
+        }
+        if (!earlyExitResult && result.result === earlyExitEvaluatorResult) {
+          earlyExitResult = { result: earlyExitEvaluatorResult, changed: isAnyChanged };
+        }
+      }
+      const finalResult = earlyExitResult != null ? earlyExitResult : { result: !earlyExitEvaluatorResult, changed: isAnyChanged };
+      if (hasMultipleClauses) {
+        onLogMessage == null ? void 0 : onLogMessage(["debug", 204, finalResult]);
+      }
+      return finalResult;
+    } finally {
+      if (hasMultipleClauses) {
+        onLogMessage == null ? void 0 : onLogMessage(["debug", 202, "ENDGROUP"]);
+      }
+    }
+  }
+};
+_evaluators = /* @__PURE__ */ new WeakMap();
+function evaluateVariantMatch(variantId, match, vec, onLogMessage, quirks) {
+  onLogMessage == null ? void 0 : onLogMessage(["info", 301, "GROUP", { id: variantId, op: match == null ? void 0 : match.op }]);
+  let result;
+  try {
+    if (!(match == null ? void 0 : match.crit)) {
+      onLogMessage == null ? void 0 : onLogMessage(["info", 302, { matched: true, description: "default variation" }]);
+      result = true;
+    } else if (!match.op || match.op === "&") {
+      result = match.crit.every((c) => evaluateMatch(c, vec, quirks != null ? quirks : {}, onLogMessage));
+    } else {
+      result = match.crit.some((c) => evaluateMatch(c, vec, quirks != null ? quirks : {}, onLogMessage));
+    }
+    onLogMessage == null ? void 0 : onLogMessage(["info", 303, result]);
+  } finally {
+    onLogMessage == null ? void 0 : onLogMessage(["info", 301, "ENDGROUP"]);
+  }
+  return result;
+}
+function evaluateMatch(crit, vec, quirks, onLogMessage) {
+  if ("t" in crit && crit.t === "q") {
+    return evaluateQuirkMatch(crit, quirks, onLogMessage);
+  } else {
+    return evaluateDimensionMatch(crit, vec, onLogMessage);
+  }
+}
+function evaluateDimensionMatch(crit, vec, onLogMessage) {
+  var _a, _b;
+  const { l: lhs, op } = crit;
+  const lhsScore = (_a = vec[lhs]) != null ? _a : 0;
+  if (op === "^") {
+    const [cat] = lhs.split(ENR_SEPARATOR);
+    let topVectorName = void 0;
+    let topScore = 0;
+    Object.keys(vec).forEach((vectorName) => {
+      if (vectorName.startsWith(`${cat}${ENR_SEPARATOR}`)) {
+        const score = vec[vectorName];
+        if (score > topScore) {
+          topVectorName = vectorName;
+          topScore = score;
+        }
+      }
+    });
+    const result = topVectorName === lhs;
+    onLogMessage == null ? void 0 : onLogMessage([
+      "info",
+      302,
+      {
+        matched: result,
+        description: `${crit.l} has the highest score in the category`
+      }
+    ]);
+    return result;
+  } else if (op === "+") {
+    const result = Math.max(...Object.values(vec)) === lhsScore && lhsScore > 0;
+    onLogMessage == null ? void 0 : onLogMessage([
+      "info",
+      302,
+      {
+        matched: result,
+        description: `${crit.l} has the highest score`
+      }
+    ]);
+    return result;
+  } else if (op === "-") {
+    const result = Math.min(...Object.values(vec)) === lhsScore && lhsScore > 0;
+    onLogMessage == null ? void 0 : onLogMessage([
+      "info",
+      302,
+      {
+        matched: result,
+        description: `${crit.l} has the lowest non-zero score`
+      }
+    ]);
+    return result;
+  }
+  let rhsScore;
+  if (crit.rDim) {
+    rhsScore = vec[crit.rDim] || 0;
+  } else {
+    rhsScore = parseInt(crit.r, 10);
+  }
+  if (isNaN(rhsScore)) {
+    onLogMessage == null ? void 0 : onLogMessage([
+      "info",
+      302,
+      {
+        matched: false,
+        description: `${(_b = crit.rDim) != null ? _b : crit.r} has no score value`
+      }
+    ]);
+    return false;
+  }
+  if (op === ">") {
+    const result = lhsScore > rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else if (op === ">=") {
+    const result = lhsScore >= rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else if (op === "<") {
+    const result = lhsScore < rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else if (op === "<=") {
+    const result = lhsScore <= rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else if (op === "=") {
+    const result = lhsScore === rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else if (op === "!=") {
+    const result = lhsScore !== rhsScore;
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
+    return result;
+  } else {
+    onLogMessage == null ? void 0 : onLogMessage([
+      "error",
+      302,
+      {
+        matched: false,
+        description: `${crit.l} ${crit.op} ${crit.rDim ? `${crit.rDim}` : crit.r}: Unknown op ${crit.op}.`
+      }
+    ]);
+    return false;
+  }
+}
+function evaluateQuirkMatch(crit, quirks, onLogMessage) {
+  var _a;
+  const { l: targetQuirk, op, r: targetValue } = crit;
+  const targetQuirkValue = (_a = quirks[targetQuirk]) != null ? _a : "";
+  if (op === "=") {
+    const result = targetQuirkValue === targetValue;
+    explainQuirk(onLogMessage, result, crit, targetQuirkValue);
+    return result;
+  } else if (op === "!=") {
+    const result = targetQuirkValue !== targetValue;
+    explainQuirk(onLogMessage, result, crit, targetQuirkValue);
+    return result;
+  } else {
+    onLogMessage == null ? void 0 : onLogMessage([
+      "error",
+      302,
+      {
+        matched: false,
+        description: `Quirk ${crit.l} ${crit.op} ${crit.r}: Unknown quirk op ${crit.op}.`
+      }
+    ]);
+    return false;
+  }
+}
+function explainScore(onLogMessage, result, crit, lhsScore, rhsScore) {
+  onLogMessage == null ? void 0 : onLogMessage([
+    "info",
+    302,
+    {
+      matched: result,
+      description: `${crit.l}[${lhsScore}] ${crit.op} ${crit.rDim ? `${crit.rDim}[${rhsScore}]` : crit.r}`
+    }
+  ]);
+}
+function explainQuirk(onLogMessage, result, crit, lhs) {
+  onLogMessage == null ? void 0 : onLogMessage([
+    "info",
+    302,
+    {
+      matched: result,
+      description: `Quirk ${crit.l}[${lhs}] ${crit.op} ${crit.r}`
+    }
+  ]);
+}
+var TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM = "default";
+function topDownCriteriaPersonalizationSelectionAlgorithm({
+  name,
+  context,
+  variations,
+  take = 1,
+  onLogMessage
+}) {
+  var _a, _b, _c;
+  onLogMessage == null ? void 0 : onLogMessage(["info", 300, "GROUP", { name, take }]);
+  try {
+    const variationMatches = [];
+    const defaultVariations = [];
+    const needsConsentToPersonalize = context.requireConsentForPersonalization;
+    const personalizationAllowed = !needsConsentToPersonalize || context.storage.data.consent;
+    for (const variation of variations) {
+      const isInvalidFormat = variation.pz && (typeof variation.pz !== "object" || variation.pz === null || !("crit" in variation.pz && Array.isArray(variation.pz.crit)));
+      let validVariation;
+      if (isInvalidFormat) {
+        const { pz, ...validParts } = variation;
+        validVariation = validParts;
+      } else {
+        validVariation = variation;
+      }
+      if ((_a = validVariation.pz) == null ? void 0 : _a.crit.length) {
+        if (personalizationAllowed && variationMatches.length !== take && evaluateVariantMatch(variation.id, validVariation.pz, context.scores, onLogMessage, context.quirks)) {
+          variationMatches.push(validVariation);
+        }
+      } else {
+        defaultVariations.push(validVariation);
+      }
+    }
+    const result = [];
+    for (let i = 0; i < variationMatches.length; i++) {
+      let isControl = (_b = context.storage.data.controlGroup) != null ? _b : false;
+      const variation = variationMatches[i];
+      if (!isControl && typeof ((_c = variation.pz) == null ? void 0 : _c.control) === "number") {
+        isControl = context.getPersonalizeVariantControl(name, i);
+        if (typeof isControl === "undefined") {
+          isControl = rollForControlGroup(variation.pz.control);
+          context.storage.updateData([
+            {
+              type: "setpersonalizecontrol",
+              data: {
+                personlizationName: name,
+                index: i,
+                control: isControl
+              }
+            }
+          ]);
+        }
+      }
+      let variantToAdd = variation;
+      if (isControl) {
+        const defaultReplacement = defaultVariations.shift();
+        if (defaultReplacement) {
+          variantToAdd = {
+            ...defaultReplacement,
+            id: variation.id
+          };
+        } else {
+          variantToAdd = void 0;
+        }
+      }
+      if (variantToAdd) {
+        result.push({ ...variantToAdd, control: isControl });
+      }
+    }
+    while (result.length < take && defaultVariations.length) {
+      result.push({ ...defaultVariations.shift(), control: false });
+    }
+    const personalized = result.some((v) => {
+      var _a2;
+      return (_a2 = v.pz) == null ? void 0 : _a2.crit.length;
+    });
+    return {
+      personalized,
+      variations: result
+    };
+  } finally {
+    onLogMessage == null ? void 0 : onLogMessage(["info", 300, "ENDGROUP"]);
+  }
+}
+var STRONGEST_SCORE_PERSONALIZATION_ALGORITHM = "ssc";
+function strongestScorePersonalizationSelectionAlgorithm({
+  name,
+  context,
+  variations,
+  take = 1,
+  onLogMessage
+}) {
+  var _a, _b;
+  onLogMessage == null ? void 0 : onLogMessage(["info", 300, "GROUP", { name, take }]);
+  try {
+    const variationMatches = [];
+    const defaultVariations = [];
+    const needsConsentToPersonalize = context.requireConsentForPersonalization;
+    const isInGlobalControlGroup = (_a = context.storage.data.controlGroup) != null ? _a : false;
+    const personalizationAllowed = !needsConsentToPersonalize || context.storage.data.consent;
+    let originalIndex = 0;
+    for (const variation of variations) {
+      const isInvalidFormat = variation.pz && typeof variation.pz !== "object";
+      let validVariation;
+      if (isInvalidFormat) {
+        const { pz, ...validParts } = variation;
+        validVariation = validParts;
+      } else {
+        validVariation = variation;
+      }
+      if ((_b = validVariation.pz) == null ? void 0 : _b.dim) {
+        if (!personalizationAllowed) {
+          continue;
+        }
+        const score = context.scores[validVariation.pz.dim];
+        if (score === void 0 || score <= 0) {
+          continue;
+        }
+        variationMatches.push({ variation: validVariation, score, originalIndex });
+        originalIndex++;
+      } else {
+        defaultVariations.push(validVariation);
+      }
+    }
+    variationMatches.sort((a, b) => {
+      const scoreComparison = b.score - a.score;
+      if (scoreComparison === 0) {
+        return a.originalIndex - b.originalIndex;
+      }
+      return scoreComparison;
+    });
+    const result = [];
+    for (let i = 0; i < variationMatches.length; i++) {
+      const variationMatch = variationMatches[i];
+      let variantToAdd = variationMatch.variation;
+      if (i >= take) {
+        continue;
+      }
+      if (isInGlobalControlGroup) {
+        const defaultReplacement = defaultVariations.shift();
+        if (defaultReplacement) {
+          variantToAdd = {
+            ...defaultReplacement,
+            id: variationMatch.variation.id
+          };
+        } else {
+          variantToAdd = void 0;
+        }
+      }
+      if (variantToAdd) {
+        result.push({ ...variantToAdd, control: isInGlobalControlGroup });
+      }
+    }
+    while (result.length < take && defaultVariations.length) {
+      result.push({ ...defaultVariations.shift(), control: false });
+    }
+    return {
+      personalized: variationMatches.length > 0 && !isInGlobalControlGroup,
+      variations: result
+    };
+  } finally {
+    onLogMessage == null ? void 0 : onLogMessage(["info", 300, "ENDGROUP"]);
+  }
+}
+var normalizeVariationDistributions = (variations) => {
+  const { values, total, missingDistribution } = variations.reduce(
+    (previous, current) => {
+      if (current.testDistribution) {
+        previous.total += current.testDistribution;
+      } else {
+        ++previous.missingDistribution;
+      }
+      previous.values.push(current.testDistribution);
+      return previous;
+    },
+    {
+      values: [],
+      total: 0,
+      missingDistribution: 0
+    }
+  );
+  if (total > 100) {
+    const autoScaleFactor = 100 / total;
+    values.forEach((value, index) => {
+      if (typeof value === "number") {
+        values[index] = value * autoScaleFactor;
+      }
+    });
+  } else if (total < 100) {
+    const remainder = 100 - total;
+    const missingSlice = remainder / missingDistribution;
+    values.forEach((value, index) => {
+      if (typeof value === "undefined") {
+        values[index] = missingSlice;
+      }
+    });
+  }
+  return values;
+};
+var testVariations = ({
+  name,
+  context,
+  variations,
+  onLogMessage
+}) => {
+  onLogMessage == null ? void 0 : onLogMessage(["info", 400, "GROUP", name]);
+  try {
+    let selectedVariant;
+    const selectedVariantId = context.getTestVariantId(name);
+    if (selectedVariantId === null) {
+      onLogMessage == null ? void 0 : onLogMessage(["error", 401, name]);
+      return { result: void 0, variantAssigned: false };
+    }
+    if (selectedVariantId) {
+      selectedVariant = variations.find((variation) => variation.id === selectedVariantId);
+      if (!selectedVariant) {
+        onLogMessage == null ? void 0 : onLogMessage([
+          "warn",
+          402,
+          { missingVariant: selectedVariantId, variants: variations.map((v) => v.id) }
+        ]);
+      }
+    }
+    if (!selectedVariant) {
+      const distributions = normalizeVariationDistributions(variations);
+      const random = Math.random() * 100;
+      let distributionOffset = 0;
+      selectedVariant = variations.find((variant, index) => {
+        const distribution = distributions[index];
+        if (random >= distributionOffset && random < distributionOffset + distribution) {
+          return variant;
+        }
+        distributionOffset += distribution;
+      });
+      if (selectedVariant) {
+        onLogMessage == null ? void 0 : onLogMessage(["info", 403, selectedVariant.id]);
+        context.setTestVariantId(name, selectedVariant.id);
+      }
+    }
+    if (selectedVariant) {
+      onLogMessage == null ? void 0 : onLogMessage(["info", 404, selectedVariant.id]);
+      if (selectedVariant.control === void 0) {
+        selectedVariant.control = variations.findIndex((variation) => variation.id === selectedVariantId) === 0;
+      }
+    }
+    return {
+      result: selectedVariant,
+      variantAssigned: !selectedVariantId
+    };
+  } finally {
+    onLogMessage == null ? void 0 : onLogMessage(["info", 400, "ENDGROUP"]);
+  }
+};
+var areCommandsEqual = (a, b) => {
+  if (a.type !== b.type) {
+    return false;
+  }
+  return dequal(a, b);
+};
+var SERVER_STATE_ID = "__UNIFORM_DATA__";
+var _data;
+var _initialData;
+var _mitt;
+var TransitionDataStore = class {
+  constructor({ initialData }) {
+    __privateAdd5(this, _data);
+    __privateAdd5(this, _initialData);
+    __privateAdd5(this, _mitt, mitt_default());
+    __publicField3(this, "events", {
+      on: __privateGet5(this, _mitt).on,
+      off: __privateGet5(this, _mitt).off
+    });
+    if (initialData) {
+      __privateSet3(this, _data, initialData);
+      __privateSet3(this, _initialData, initialData);
+    }
+  }
+  get data() {
+    return __privateGet5(this, _data);
+  }
+  get initialData() {
+    return __privateGet5(this, _initialData);
+  }
+  /**
+   * Updates data in the transition storage.
+   * @param commands - Commands to execute against existing stored value (event based stores)
+   * @param computedValue - Pre-computed new value against existing value (object based stores)
+   * @returns Resolved promise when the data has been updated
+   */
+  updateData(commands, computedValue) {
+    __privateSet3(this, _data, computedValue);
+    return this.handleUpdateData(commands, computedValue);
+  }
+  /**
+   * Deletes a visitor's stored data, forgetting them.
+   * @param fromAllDevices - false: logout from this device ID. true: forget all data about the visitor and their identity.
+   */
+  async delete(fromAllDevices) {
+    __privateSet3(this, _data, void 0);
+    await this.handleDelete(fromAllDevices);
+  }
+  signalAsyncDataUpdate(newScores) {
+    if (dequal(this.data, newScores)) {
+      return;
+    }
+    __privateSet3(this, _data, newScores);
+    __privateGet5(this, _mitt).emit("dataUpdatedAsync", newScores);
+  }
+  /**
+   * When we load on the client side after a server side rendering has occurred (server to client transition),
+   * we can have a page script (ID: __UNIFORM_DATA__) that contains the computed visitor data from the SSR/edge render.
+   * This data is injected into the first render to allow score syncing and the server to request commands be applied
+   * to the client side data store.
+   */
+  getClientTransitionState() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const matchesElement = document.getElementById(SERVER_STATE_ID);
+    return (matchesElement == null ? void 0 : matchesElement.textContent) ? JSON.parse(matchesElement.textContent) : void 0;
+  }
+};
+_data = /* @__PURE__ */ new WeakMap();
+_initialData = /* @__PURE__ */ new WeakMap();
+_mitt = /* @__PURE__ */ new WeakMap();
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var b2s = alphabet.split("");
+var s2b = new Array(123);
+for (let i = 0; i < alphabet.length; i++) {
+  s2b[alphabet.charCodeAt(i)] = i;
+}
+var ntob = (number) => {
+  if (number < 0) return `-${ntob(-number)}`;
+  let lo = number >>> 0;
+  let hi = number / 4294967296 >>> 0;
+  let right = "";
+  while (hi > 0) {
+    right = b2s[63 & lo] + right;
+    lo >>>= 6;
+    lo |= (63 & hi) << 26;
+    hi >>>= 6;
+  }
+  let left = "";
+  do {
+    left = b2s[63 & lo] + left;
+    lo >>>= 6;
+  } while (lo > 0);
+  return left + right;
+};
+var bton = (base64) => {
+  let number = 0;
+  const sign = base64.charAt(0) === "-" ? 1 : 0;
+  for (let i = sign; i < base64.length; i++) {
+    number = number * 64 + s2b[base64.charCodeAt(i)];
+  }
+  return sign ? -number : number;
+};
+var ssr = typeof document === "undefined";
+var UNIFORM_DEFAULT_COOKIE_NAME = "ufvd";
+var UNIFORM_DEFAULT_QUIRK_COOKIE_NAME = `ufvdqk`;
+var _cookieName;
+var _quirkCookieName;
+var _cookieAttributes;
+var _quirksEnabled;
+var CookieTransitionDataStore = class extends TransitionDataStore {
+  constructor({
+    serverCookieValue,
+    experimental_quirksEnabled,
+    quirkCookieValue,
+    quirkCookieName = UNIFORM_DEFAULT_QUIRK_COOKIE_NAME,
+    cookieName = UNIFORM_DEFAULT_COOKIE_NAME,
+    cookieAttributes = { sameSite: "lax" }
+  }) {
+    super({
+      initialData: ssr ? parseScoreCookie(serverCookieValue, experimental_quirksEnabled ? quirkCookieValue : void 0) : void 0
+    });
+    __privateAdd5(this, _cookieName);
+    __privateAdd5(this, _quirkCookieName);
+    __privateAdd5(this, _cookieAttributes);
+    __privateAdd5(this, _quirksEnabled);
+    __privateSet3(this, _cookieName, cookieName);
+    __privateSet3(this, _cookieAttributes, cookieAttributes);
+    __privateSet3(this, _quirkCookieName, quirkCookieName);
+    __privateSet3(this, _quirksEnabled, experimental_quirksEnabled || false);
+  }
+  handleDelete() {
+    if (ssr) return Promise.resolve();
+    api.remove(__privateGet5(this, _cookieName));
+    return Promise.resolve();
+  }
+  async handleUpdateData(_, computedValue) {
+    if (ssr) return;
+    if (computedValue.consent) {
+      api.set(__privateGet5(this, _cookieName), serializeCookie(computedValue), __privateGet5(this, _cookieAttributes));
+      if (__privateGet5(this, _quirksEnabled) && Object.keys(computedValue.quirks || {}).length) {
+        const quirkCookieValue = serializeQuirks(computedValue.quirks || {});
+        api.set(__privateGet5(this, _quirkCookieName), quirkCookieValue, __privateGet5(this, _cookieAttributes));
+      }
+    } else {
+      api.remove(__privateGet5(this, _cookieName));
+      if (__privateGet5(this, _quirksEnabled)) {
+        api.remove(__privateGet5(this, _quirkCookieName));
+      }
+    }
+  }
+};
+_cookieName = /* @__PURE__ */ new WeakMap();
+_quirkCookieName = /* @__PURE__ */ new WeakMap();
+_cookieAttributes = /* @__PURE__ */ new WeakMap();
+_quirksEnabled = /* @__PURE__ */ new WeakMap();
+var TYPE_SEP = "~";
+var PAIR_SEP = "!";
+var KV_SEP = "-";
+var QUIRK_SEP = "!!";
+function parseScoreCookie(cookieValue, quirkCookieValue) {
+  if (!cookieValue) return;
+  const types = cookieValue.split(TYPE_SEP);
+  if (types.length > 5) return;
+  const [abTestData, sessionScores, visitorScores, controlGroup, personalizeVariants] = types;
+  const data = {
+    // this is true since we're reading a cookie, which wouldn't exist if consent wasn't given
+    consent: true,
+    sessionScores: decodeCookieType(parseCookieScores(sessionScores)),
+    scores: decodeCookieType(parseCookieScores(visitorScores)),
+    tests: parseCookieType(abTestData),
+    controlGroup: controlGroup === "1",
+    personalizeVariants: decodePersonalizeVariants(personalizeVariants)
+  };
+  if (quirkCookieValue) {
+    data.quirks = parseQuirkCookie(quirkCookieValue);
+  }
+  return data;
+}
+function parseQuirkCookie(quirkCookieValue) {
+  const pairs = quirkCookieValue.split(QUIRK_SEP);
+  const splitPairs = pairs.map((pair) => {
+    const sep = pair.indexOf(KV_SEP);
+    if (sep === -1) {
+      return void 0;
+    }
+    return [pair.slice(0, sep), pair.slice(sep + 1)];
+  });
+  const areAllPairsValid = splitPairs.every((pair) => pair !== void 0);
+  if (!areAllPairsValid) {
+    return {};
+  }
+  return splitPairs.reduce((acc, cur) => {
+    const [key, value] = cur;
+    acc[key] = value;
+    return acc;
+  }, {});
+}
+function parseCookieScores(type) {
+  if (!type) {
+    return {};
+  }
+  const pairs = type.split(PAIR_SEP).map((pair) => pair.split(KV_SEP));
+  return pairs.reduce((acc, cur) => {
+    if (cur.length < 2) return acc;
+    const key = cur.slice(0, -1).join(KV_SEP);
+    acc[key] = cur[cur.length - 1];
+    return acc;
+  }, {});
+}
+function parseCookieType(type) {
+  if (!type) {
+    return {};
+  }
+  const pairs = type.split(PAIR_SEP).map((pair) => pair.split(KV_SEP));
+  return pairs.reduce((acc, cur) => {
+    if (cur.length < 2) return acc;
+    acc[cur[0]] = cur.slice(1).join("-");
+    return acc;
+  }, {});
+}
+function decodeCookieType(type) {
+  return Object.entries(type).reduce((acc, [key, value]) => {
+    acc[key] = bton(value);
+    return acc;
+  }, {});
+}
+function serializeCookie(data) {
+  return [
+    serializeCookieType(data.tests),
+    serializeCookieType(encodeCookieType(data.sessionScores)),
+    serializeCookieType(encodeCookieType(data.scores)),
+    data.controlGroup ? "1" : "0",
+    serializePersonalizeVariants(data)
+  ].join(TYPE_SEP);
+}
+function serializePersonalizeVariants({
+  personalizeVariants
+}) {
+  const data = {};
+  if (typeof personalizeVariants === "object") {
+    Object.keys(personalizeVariants).forEach((personalizationName) => {
+      const results = [];
+      const variants = personalizeVariants[personalizationName];
+      variants.forEach((variant) => {
+        results.push(`${variant.index}:${variant.control ? "1" : "0"}`);
+      });
+      data[personalizationName] = results.join(",");
+    });
+  }
+  const serialized = serializeCookieType(data);
+  return serialized;
+}
+function decodePersonalizeVariants(data) {
+  const parsed = parseCookieType(data);
+  const keys = Object.keys(parsed);
+  if (!keys.length) {
+    return void 0;
+  }
+  const results = {};
+  Object.keys(parsed).forEach((k) => {
+    const variants = parsed[k].split(",");
+    const key = decodeURIComponent(k);
+    results[key] = variants.map((variant) => {
+      const [index, control] = variant.split(":");
+      return {
+        index: parseInt(index, 10),
+        control: control === "1"
+      };
+    });
+  });
+  return results;
+}
+function encodeCookieType(type) {
+  return Object.entries(type).reduce((acc, [key, value]) => {
+    acc[key] = ntob(value);
+    return acc;
+  }, {});
+}
+function serializeCookieType(type) {
+  return Object.entries(type).map((kv) => kv.join(KV_SEP)).join(PAIR_SEP);
+}
+function serializeQuirks(quirks) {
+  return Object.entries(quirks).map((kv) => kv.join(KV_SEP)).join(QUIRK_SEP);
+}
+var _EdgeTransitionDataStore_instances;
+var fetchData_fn;
+_EdgeTransitionDataStore_instances = /* @__PURE__ */ new WeakSet();
+fetchData_fn = async function() {
+  const serviceData = await new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(void 0);
+    }, 2e3);
+  });
+  if (serviceData) {
+    this.signalAsyncDataUpdate(serviceData);
+  }
+};
+var emptyVisitorData = () => ({
+  quirks: {},
+  scores: {},
+  sessionScores: {},
+  tests: {},
+  goals: {},
+  consent: false,
+  controlGroup: false,
+  personalizeVariants: {}
+});
+var clone = (0, import_rfdc.default)();
+function applyCommandsToData(commands, state) {
+  const newData = state ? clone(state) : emptyVisitorData();
+  commands.forEach((command) => {
+    var _a, _b, _c;
+    switch (command.type) {
+      case "consent":
+        newData.consent = command.data;
+        break;
+      case "setquirk":
+        newData.quirks[command.data.key] = command.data.value;
+        break;
+      case "settest":
+        newData.tests[command.data.test] = command.data.variant;
+        break;
+      case "modscore":
+        const delta = Number(command.data.delta);
+        if (isNaN(delta)) {
+          throw new Error("Non-number delta received");
+        }
+        const existing = (_a = newData.scores[command.data.dimension]) != null ? _a : 0;
+        newData.scores[command.data.dimension] = existing + delta;
+        break;
+      case "modscoreS":
+        const deltaS = Number(command.data.delta);
+        if (isNaN(deltaS)) {
+          throw new Error("Non-number delta received");
+        }
+        const existingS = (_b = newData.sessionScores[command.data.dimension]) != null ? _b : 0;
+        newData.sessionScores[command.data.dimension] = existingS + deltaS;
+        break;
+      case "identify":
+        break;
+      case "setcontrol":
+        newData.controlGroup = command.data;
+        break;
+      case "setpersonalizecontrol":
+        if (!newData.personalizeVariants) {
+          newData.personalizeVariants = {};
+        }
+        if (!newData.personalizeVariants[command.data.personlizationName]) {
+          newData.personalizeVariants[command.data.personlizationName] = [];
+        }
+        const existingDef = newData.personalizeVariants[command.data.personlizationName].find(
+          (i) => i.index === command.data.index
+        );
+        if (!existingDef) {
+          newData.personalizeVariants[command.data.personlizationName].push({
+            index: command.data.index,
+            control: command.data.control
+          });
+        } else {
+          console.warn("Overwriting existing control group definition is not allowed");
+        }
+        break;
+      case "setgoal":
+        newData.goals = (_c = newData.goals) != null ? _c : {};
+        newData.goals[command.data.goal] = true;
+        break;
+      default:
+        throw new Error(`Unknown command`);
+    }
+  });
+  return newData;
+}
+var _LocalStorage_instances;
+var key_fn;
+var LocalStorage = class {
+  constructor(partitionKey) {
+    __publicField3(this, "partitionKey", partitionKey);
+    __privateAdd5(this, _LocalStorage_instances);
+    __publicField3(this, "inMemoryFallback", {});
+    __publicField3(this, "hasLocalStorageObject", typeof document !== "undefined" && typeof localStorage !== "undefined");
+  }
+  get(key) {
+    const keyValue = __privateMethod2(this, _LocalStorage_instances, key_fn).call(this, key);
+    const fallbackValue = this.inMemoryFallback[keyValue];
+    if (!this.hasLocalStorageObject || fallbackValue) {
+      return fallbackValue;
+    }
+    try {
+      const value = localStorage.getItem(keyValue);
+      return value ? JSON.parse(value) : void 0;
+    } catch (e) {
+      return fallbackValue;
+    }
+  }
+  set(key, value, storageConsent) {
+    const keyValue = __privateMethod2(this, _LocalStorage_instances, key_fn).call(this, key);
+    this.inMemoryFallback[keyValue] = value;
+    if (!this.hasLocalStorageObject || !storageConsent) {
+      return;
+    }
+    try {
+      localStorage.setItem(keyValue, JSON.stringify(value));
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+  delete(key, leaveInMemory) {
+    const keyValue = __privateMethod2(this, _LocalStorage_instances, key_fn).call(this, key);
+    if (!leaveInMemory) {
+      delete this.inMemoryFallback[keyValue];
+    }
+    try {
+      localStorage.removeItem(keyValue);
+    } catch (e) {
+    }
+  }
+};
+_LocalStorage_instances = /* @__PURE__ */ new WeakSet();
+key_fn = function(key) {
+  return this.partitionKey ? `${this.partitionKey}.${key}` : key;
+};
+var STORAGE_KEY = "ufvisitor";
+var _mitt2;
+var _persist;
+var _visitTimeout;
+var _options;
+var _VisitorDataStore_instances;
+var currentData_get;
+var replaceData_fn;
+var setVisitTimeout_fn;
+var isExpired_fn;
+var handleCaps_fn;
+var defaultData_fn;
+var VisitorDataStore = class {
+  constructor(options) {
+    __privateAdd5(this, _VisitorDataStore_instances);
+    __privateAdd5(this, _mitt2, mitt_default());
+    __privateAdd5(this, _persist);
+    __privateAdd5(this, _visitTimeout);
+    __privateAdd5(this, _options);
+    __publicField3(this, "events", {
+      on: __privateGet5(this, _mitt2).on,
+      off: __privateGet5(this, _mitt2).off
+    });
+    __privateSet3(this, _options, options);
+    __privateSet3(this, _persist, new LocalStorage(options.partitionKey));
+    if (!__privateGet5(this, _VisitorDataStore_instances, currentData_get)) {
+      __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(this, __privateMethod2(this, _VisitorDataStore_instances, defaultData_fn).call(this), true);
+    }
+    if (options.transitionStore) {
+      const serverToClientTransitionState = options.transitionStore.getClientTransitionState();
+      if (serverToClientTransitionState && options.onServerTransitionReceived) {
+        options.onServerTransitionReceived(serverToClientTransitionState);
+      }
+      options.transitionStore.events.on("dataUpdatedAsync", (data) => {
+        __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(this, {
+          ...__privateGet5(this, _VisitorDataStore_instances, currentData_get).visitorData,
+          ...data
+        });
+      });
+      const transitionData = options.transitionStore.data;
+      if (transitionData) {
+        __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(
+          this,
+          // we know _currentData is not empty because we inited it above if it was
+          { ...__privateGet5(this, _VisitorDataStore_instances, currentData_get).visitorData, ...transitionData },
+          true
+        );
+      }
+    }
+  }
+  /** Gets the current visitor data. This property is always up to date. */
+  get data() {
+    var _a, _b, _c;
+    const data = (_a = __privateGet5(this, _VisitorDataStore_instances, currentData_get)) != null ? _a : { visitorData: __privateMethod2(this, _VisitorDataStore_instances, defaultData_fn).call(this), updated: (/* @__PURE__ */ new Date()).getTime() };
+    if (__privateMethod2(this, _VisitorDataStore_instances, isExpired_fn).call(this, data)) {
+      const { sessionScores, ...newData } = data.visitorData;
+      __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(this, { ...newData, sessionScores: {} });
+      (_c = (_b = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _c.call(_b, ["info", 120]);
+      return __privateGet5(this, _VisitorDataStore_instances, currentData_get).visitorData;
+    }
+    return data.visitorData;
+  }
+  get decayEnabled() {
+    return !!__privateGet5(this, _options).decay;
+  }
+  get options() {
+    return __privateGet5(this, _options);
+  }
+  /** Push data update command(s) into the visitor data */
+  async updateData(commands) {
+    var _a, _b, _c;
+    if (commands.length === 0) {
+      return;
+    }
+    (_b = (_a = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _b.call(_a, ["debug", 101, commands]);
+    const newData = applyCommandsToData(commands, this.data);
+    if (commands.some((c) => c.type === "consent" && !c.data)) {
+      __privateGet5(this, _persist).delete(STORAGE_KEY, true);
+    }
+    __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(this, newData);
+    await ((_c = __privateGet5(this, _options).transitionStore) == null ? void 0 : _c.updateData(commands, __privateGet5(this, _VisitorDataStore_instances, currentData_get).visitorData));
+    __privateGet5(this, _mitt2).emit("commandsExecuted", commands);
+  }
+  /**
+   * Deletes visitor data (forgetting them)
+   * In most cases you should use forget() on the Context instead of this function, which also clears the Context state.
+   * @param fromAllDevices - for an identified user, whether to delete all their data (for the entire account) - true, or data for this device (sign out) - false
+   */
+  async delete(fromAllDevices) {
+    var _a, _b, _c, _d, _e;
+    (_b = (_a = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _b.call(_a, ["info", 103, "GROUP", fromAllDevices]);
+    try {
+      __privateGet5(this, _persist).delete(STORAGE_KEY, false);
+      await ((_c = __privateGet5(this, _options).transitionStore) == null ? void 0 : _c.delete(fromAllDevices));
+      __privateMethod2(this, _VisitorDataStore_instances, replaceData_fn).call(this, __privateMethod2(this, _VisitorDataStore_instances, defaultData_fn).call(this));
+    } finally {
+      (_e = (_d = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _e.call(_d, ["info", 103, "ENDGROUP"]);
+    }
+  }
+};
+_mitt2 = /* @__PURE__ */ new WeakMap();
+_persist = /* @__PURE__ */ new WeakMap();
+_visitTimeout = /* @__PURE__ */ new WeakMap();
+_options = /* @__PURE__ */ new WeakMap();
+_VisitorDataStore_instances = /* @__PURE__ */ new WeakSet();
+currentData_get = function() {
+  return __privateGet5(this, _persist).get(STORAGE_KEY);
+};
+replaceData_fn = function(data, quiet = false) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const oldData = __privateGet5(this, _VisitorDataStore_instances, currentData_get);
+  const now = Date.now();
+  __privateMethod2(this, _VisitorDataStore_instances, handleCaps_fn).call(this, data.scores);
+  __privateMethod2(this, _VisitorDataStore_instances, handleCaps_fn).call(this, data.sessionScores);
+  (_b = (_a = __privateGet5(this, _options)).decay) == null ? void 0 : _b.call(_a, {
+    now,
+    lastUpd: oldData == null ? void 0 : oldData.updated,
+    scores: data.scores,
+    sessionScores: data.sessionScores,
+    onLogMessage: __privateGet5(this, _options).onLogMessage
+  });
+  const haveScoresChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.scores, data.scores);
+  const haveSessionScoresChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.sessionScores, data.sessionScores);
+  const haveQuirksChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.quirks, data.quirks);
+  const haveTestsChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.tests, data.tests);
+  const haveGoalsChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.goals, data.goals);
+  const updatedData = {
+    updated: now,
+    visitorData: data
+  };
+  __privateMethod2(this, _VisitorDataStore_instances, setVisitTimeout_fn).call(this);
+  __privateGet5(this, _persist).set(STORAGE_KEY, updatedData, !!data.consent);
+  (_d = (_c = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _d.call(_c, ["debug", 102, data]);
+  if (!quiet) {
+    if (haveScoresChanged || haveSessionScoresChanged) {
+      __privateGet5(this, _mitt2).emit("scoresUpdated", data);
+    }
+    if (haveQuirksChanged) {
+      __privateGet5(this, _mitt2).emit("quirksUpdated", data);
+    }
+    if (haveTestsChanged) {
+      __privateGet5(this, _mitt2).emit("testsUpdated", data);
+    }
+    if (((_e = oldData == null ? void 0 : oldData.visitorData) == null ? void 0 : _e.consent) !== data.consent) {
+      __privateGet5(this, _mitt2).emit("consentUpdated", data);
+    }
+    if (((_f = oldData == null ? void 0 : oldData.visitorData) == null ? void 0 : _f.controlGroup) !== data.controlGroup) {
+      __privateGet5(this, _mitt2).emit("controlGroupUpdated", data);
+      (_i = (_h = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _i.call(_h, ["debug", 104, (_g = data.controlGroup) != null ? _g : false]);
+    }
+    if (haveGoalsChanged) {
+      const newGoalKeys = Object.keys((_j = data.goals) != null ? _j : {});
+      for (let i = 0; i < newGoalKeys.length; i++) {
+        const key = newGoalKeys[i];
+        if (!((_k = oldData == null ? void 0 : oldData.visitorData.goals) == null ? void 0 : _k[key])) {
+          __privateGet5(this, _mitt2).emit("goalConverted", { goalId: key });
+        }
+      }
+    }
+  }
+};
+setVisitTimeout_fn = function() {
+  if (typeof document === "undefined" || !__privateGet5(this, _options).visitLifespan) {
+    return;
+  }
+  if (__privateGet5(this, _visitTimeout)) {
+    window.clearTimeout(__privateGet5(this, _visitTimeout));
+  }
+  __privateSet3(this, _visitTimeout, window.setTimeout(() => {
+    this.data;
+  }, __privateGet5(this, _options).visitLifespan + 50));
+};
+isExpired_fn = function(data) {
+  const expires = __privateGet5(this, _options).visitLifespan;
+  return expires ? data.updated + expires < Date.now() : false;
+};
+handleCaps_fn = function(scores) {
+  var _a, _b;
+  if (!__privateGet5(this, _options).manifest) {
+    return;
+  }
+  for (const dim in scores) {
+    const score = scores[dim];
+    const dimDef = __privateGet5(this, _options).manifest.getDimensionByKey(dim);
+    if (!dimDef) {
+      continue;
+    }
+    if (score > dimDef.cap) {
+      (_b = (_a = __privateGet5(this, _options)).onLogMessage) == null ? void 0 : _b.call(_a, ["debug", 110, { dim, score, cap: dimDef.cap }]);
+      scores[dim] = dimDef.cap;
+    }
+  }
+};
+defaultData_fn = function() {
+  var _a, _b, _c;
+  return {
+    ...emptyVisitorData(),
+    consent: (_a = __privateGet5(this, _options).defaultConsent) != null ? _a : false,
+    controlGroup: (_c = (_b = __privateGet5(this, _options).manifest) == null ? void 0 : _b.rollForControlGroup()) != null ? _c : false
+  };
+};
+var CONTEXTUAL_EDITING_TEST_NAME = "contextual_editing_test";
+var CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID = "contextual_editing_test_selected_variant";
+var _personalizationSelectionAlgorithms;
+var _serverTransitionState;
+var _scores;
+var _state;
+var _pzCache;
+var _plugins;
+var _commands;
+var _requireConsentForPersonalization;
+var _mitt3;
+var _Context_instances;
+var emitTest_fn;
+var updateGoals_fn;
+var updateComputedScores_fn;
+var calculateScores_fn;
+var Context = class {
+  constructor(options) {
+    __privateAdd5(this, _Context_instances);
+    __publicField3(this, "manifest");
+    __privateAdd5(this, _personalizationSelectionAlgorithms);
+    __privateAdd5(this, _serverTransitionState);
+    __privateAdd5(this, _scores, {});
+    __privateAdd5(this, _state);
+    __privateAdd5(this, _pzCache, {});
+    __privateAdd5(this, _plugins);
+    __privateAdd5(this, _commands);
+    __privateAdd5(this, _requireConsentForPersonalization);
+    __privateAdd5(this, _mitt3, mitt_default());
+    __publicField3(this, "events", {
+      on: __privateGet5(this, _mitt3).on,
+      off: __privateGet5(this, _mitt3).off
+    });
+    __publicField3(this, "storage");
+    var _a, _b, _c;
+    const { manifest, ...storageOptions } = options;
+    __privateSet3(this, _state, {});
+    __privateSet3(this, _plugins, options.plugins);
+    __privateSet3(this, _requireConsentForPersonalization, options.requireConsentForPersonalization);
+    if (typeof options.transitionStore !== "undefined") {
+      __privateSet3(this, _commands, []);
+    }
+    __privateSet3(this, _personalizationSelectionAlgorithms, {
+      [TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM]: topDownCriteriaPersonalizationSelectionAlgorithm,
+      [STRONGEST_SCORE_PERSONALIZATION_ALGORITHM]: strongestScorePersonalizationSelectionAlgorithm
+    });
+    (_a = __privateGet5(this, _plugins)) == null ? void 0 : _a.forEach((plugin) => {
+      if (!plugin.personalizationSelectionAlgorithms) {
+        return;
+      }
+      __privateSet3(this, _personalizationSelectionAlgorithms, {
+        ...__privateGet5(this, _personalizationSelectionAlgorithms),
+        ...plugin.personalizationSelectionAlgorithms
+      });
+    });
+    (_b = __privateGet5(this, _plugins)) == null ? void 0 : _b.forEach((plugin) => {
+      if (!plugin.logDrain) {
+        return;
+      }
+      __privateGet5(this, _mitt3).on("log", plugin.logDrain);
+    });
+    __privateGet5(this, _mitt3).emit("log", ["info", 1, "GROUP"]);
+    try {
+      this.manifest = new ManifestInstance({
+        onLogMessage: (message) => __privateGet5(this, _mitt3).emit("log", message),
+        manifest,
+        evaluator: new GroupCriteriaEvaluator({
+          CK: cookieEvaluator,
+          QS: queryStringEvaluator,
+          QK: quirkEvaluator,
+          PVC: pageViewCountEvaluator,
+          EVT: eventEvaluator,
+          PV: currentPageEvaluator
+        })
+      });
+      this.storage = new VisitorDataStore({
+        ...storageOptions,
+        manifest: this.manifest,
+        onServerTransitionReceived: (state) => {
+          __privateSet3(this, _serverTransitionState, state);
+          if (state.ssv) {
+            __privateSet3(this, _scores, state.ssv);
+            __privateGet5(this, _mitt3).emit("log", ["debug", 130, state]);
+          }
+          if (state.compositionMetadata) {
+            __privateGet5(this, _state).compositionMetadata = state.compositionMetadata;
+          }
+        },
+        onLogMessage: (message) => __privateGet5(this, _mitt3).emit("log", message)
+      });
+      this.storage.events.on("scoresUpdated", __privateMethod2(this, _Context_instances, updateComputedScores_fn).bind(this));
+      if (!__privateGet5(this, _serverTransitionState)) {
+        __privateMethod2(this, _Context_instances, updateComputedScores_fn).call(this, this.storage.data);
+      }
+      this.storage.events.on("quirksUpdated", (quirks) => {
+        const updates = this.manifest.computeSignals({
+          scores: __privateGet5(this, _scores),
+          state: __privateGet5(this, _state),
+          previousState: __privateGet5(this, _state),
+          visitor: this.storage.data
+        });
+        __privateMethod2(this, _Context_instances, updateGoals_fn).call(this, {
+          quirks: quirks.quirks,
+          scores: void 0
+        });
+        this.storage.updateData(updates);
+        __privateGet5(this, _mitt3).emit("quirksUpdated", quirks.quirks);
+        __privateGet5(this, _mitt3).emit("log", ["info", 4, quirks.quirks]);
+      });
+      (_c = __privateGet5(this, _plugins)) == null ? void 0 : _c.forEach((plugin) => {
+        if (!plugin.init) {
+          return;
+        }
+        plugin.init(this);
+      });
+    } finally {
+      __privateGet5(this, _mitt3).emit("log", ["info", 1, "ENDGROUP"]);
+    }
+    if (typeof window !== "undefined") {
+      window.__UNIFORM_CONTEXTUAL_EDITING_CONTEXT__ = this;
+    }
+  }
+  /** Gets the current visitor's dimension score vector. */
+  get scores() {
+    return __privateGet5(this, _scores);
+  }
+  /** Gets the current visitor's quirks values. */
+  get quirks() {
+    var _a, _b;
+    return (_b = (_a = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _a.quirks) != null ? _b : this.storage.data.quirks;
+  }
+  get requireConsentForPersonalization() {
+    return __privateGet5(this, _requireConsentForPersonalization);
+  }
+  /**
+   * Updates the Context with new data of any sort, such as
+   * new URLs, cookies, quirks, and enrichments.
+   *
+   * Only properties that are set in the data parameter will be updated,
+   * for example if passing `url` but not `cookies`, the last known state of cookies will be preserved.
+   *
+   * Properties that do not result in a changed state,
+   * i.e. pushing the same URL or cookies as before,
+   * will NOT result in a recomputation of signal state.
+   */
+  async update(newData) {
+    var _a, _b, _c, _d, _e;
+    const commands = [];
+    const newServerSideTests = {};
+    if ((_a = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _a.quirks) {
+      newData = {
+        ...newData,
+        quirks: {
+          ...__privateGet5(this, _serverTransitionState).quirks,
+          ...newData.quirks || {}
+        }
+      };
+    }
+    if ((_b = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _b.tests) {
+      const testEntries = Object.entries(__privateGet5(this, _serverTransitionState).tests);
+      if (testEntries.length > 0) {
+        const validTests = [];
+        testEntries.forEach(([testName, testVariantId]) => {
+          if (!this.storage.data.tests[testName]) {
+            validTests.push([testName, testVariantId]);
+            newServerSideTests[testName] = testVariantId;
+          }
+        });
+        commands.push(
+          ...validTests.map(([key, value]) => ({
+            type: "settest",
+            data: { test: key, variant: value }
+          }))
+        );
+      }
+    }
+    if ((_c = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _c.personalizeVariants) {
+      Object.keys(__privateGet5(this, _serverTransitionState).personalizeVariants).forEach((personalizationName) => {
+        const variants = __privateGet5(this, _serverTransitionState).personalizeVariants[personalizationName];
+        variants.forEach((e) => {
+          commands.push({
+            type: "setpersonalizecontrol",
+            data: { personlizationName: personalizationName, index: e.index, control: e.control }
+          });
+        });
+      });
+    }
+    try {
+      __privateGet5(this, _mitt3).emit("log", [
+        "info",
+        2,
+        "GROUP",
+        {
+          ...newData,
+          // need to convert url to string so it can be json serialized
+          // to go over postMessage to chrome extension
+          url: (_d = newData.url) == null ? void 0 : _d.toString()
+        }
+      ]);
+      if (newData.quirks) {
+        commands.push(
+          ...Object.entries(newData.quirks).map(([key, value]) => ({
+            type: "setquirk",
+            data: { key, value }
+          }))
+        );
+      }
+      if (newData.enrichments) {
+        newData.enrichments.forEach((enrichment) => {
+          const dimension = getEnrichmentVectorKey(enrichment.cat, enrichment.key);
+          const dimData = this.manifest.getDimensionByKey(dimension);
+          if (dimData) {
+            commands.push({
+              type: "modscore",
+              data: {
+                dimension,
+                delta: enrichment.str
+              }
+            });
+          } else {
+            __privateGet5(this, _mitt3).emit("log", ["warn", 5, enrichment]);
+          }
+        });
+      }
+      const effectiveNewStateForSignalComputation = {
+        ...__privateGet5(this, _state),
+        ...newData
+      };
+      commands.push(
+        ...this.manifest.computeSignals({
+          state: effectiveNewStateForSignalComputation,
+          previousState: __privateGet5(this, _state),
+          visitor: this.storage.data,
+          // re-compute using scores from storage instead of the current scores since
+          // server transition scores might have adjusted values already integrated into them,
+          // which causes issues when you are near limits.
+          scores: __privateGet5(this, _serverTransitionState) ? __privateMethod2(this, _Context_instances, calculateScores_fn).call(this, this.storage.data) : __privateGet5(this, _scores)
+        })
+      );
+      const previousCompositionMetadata = __privateGet5(this, _state).compositionMetadata;
+      __privateSet3(this, _state, {
+        ...__privateGet5(this, _state),
+        ...newData
+      });
+      if (newData.compositionMetadata && // deep equal is not too bad, as we only have 1 level of depth in dynamic inputs
+      !dequal(previousCompositionMetadata, __privateGet5(this, _state).compositionMetadata)) {
+        __privateGet5(this, _mitt3).emit("canvasDataUpdated", __privateGet5(this, _state).compositionMetadata);
+        __privateGet5(this, _state).compositionMetadata = newData.compositionMetadata;
+      }
+      await this.storage.updateData(commands);
+      if (__privateGet5(this, _serverTransitionState)) {
+        await this.processServerCommands({
+          serverCommands: __privateGet5(this, _serverTransitionState).commands,
+          commands
+        });
+        __privateMethod2(this, _Context_instances, updateComputedScores_fn).call(this, this.storage.data);
+        Object.entries(newServerSideTests).forEach(([testName, testVariantId]) => {
+          __privateMethod2(this, _Context_instances, emitTest_fn).call(this, {
+            name: testName,
+            variantId: testVariantId,
+            variantAssigned: true,
+            control: false,
+            compositionMetadata: void 0
+          });
+        });
+        const haveQuirksChanged = __privateGet5(this, _serverTransitionState) && !dequal(__privateGet5(this, _serverTransitionState).quirks, this.storage.data.quirks);
+        __privateSet3(this, _serverTransitionState, void 0);
+        if (haveQuirksChanged) {
+          __privateGet5(this, _mitt3).emit("quirksUpdated", this.storage.data.quirks);
+        }
+        __privateGet5(this, _mitt3).emit("log", ["debug", 131]);
+      }
+      if (__privateGet5(this, _plugins)) {
+        for (let i = 0; i < __privateGet5(this, _plugins).length; i++) {
+          const plugin = __privateGet5(this, _plugins)[i];
+          if (!plugin.update) {
+            continue;
+          }
+          await plugin.update(newData, __privateGet5(this, _scores));
+        }
+      }
+      (_e = __privateGet5(this, _commands)) == null ? void 0 : _e.push(...commands);
+    } finally {
+      __privateGet5(this, _mitt3).emit("log", ["info", 2, "ENDGROUP"]);
+    }
+  }
+  async processServerCommands({
+    serverCommands,
+    commands
+  }) {
+    if (!(serverCommands == null ? void 0 : serverCommands.length)) {
+      return;
+    }
+    const notExecutedCommands = [];
+    serverCommands.forEach((serverCommand) => {
+      const found = commands.find((command) => {
+        return areCommandsEqual(command, serverCommand);
+      });
+      if (!found) {
+        notExecutedCommands.push(serverCommand);
+      }
+    });
+    if (notExecutedCommands.length > 0) {
+      await this.storage.updateData(notExecutedCommands);
+    }
+  }
+  /** use test() instead */
+  getTestVariantId(testName) {
+    var _a, _b, _c, _d;
+    const definition = this.manifest.getTest(testName);
+    if (!definition) {
+      __privateGet5(this, _mitt3).emit("log", ["warn", 401, testName]);
+      return null;
+    }
+    return (_d = (_c = definition.wv) != null ? _c : (_b = (_a = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _a.tests) == null ? void 0 : _b[testName]) != null ? _d : this.storage.data.tests[testName];
+  }
+  /** use test() instead */
+  setTestVariantId(testName, variantId) {
+    this.storage.updateData([
+      {
+        type: "settest",
+        data: {
+          test: testName,
+          variant: variantId
+        }
+      }
+    ]);
+  }
+  getPersonalizeVariantControl(name, index) {
+    var _a, _b, _c;
+    const source = (_b = (_a = __privateGet5(this, _serverTransitionState)) == null ? void 0 : _a.personalizeVariants) != null ? _b : this.storage.data.personalizeVariants;
+    const variants = (_c = source == null ? void 0 : source[name]) != null ? _c : [];
+    const variant = variants.find((v) => v.index === index);
+    return variant == null ? void 0 : variant.control;
+  }
+  /**
+   * Writes a message to the Context log sink.
+   * Used by Uniform internal SDK; not intended for public use.
+   */
+  log(...message) {
+    __privateGet5(this, _mitt3).emit("log", message);
+  }
+  /** Executes an A/B test with a given set of variants, showing the visitor's assigned variant (or selecting one to assign, if none is set yet) */
+  test(options) {
+    var _a, _b, _c, _d, _e;
+    if (options.name === CONTEXTUAL_EDITING_TEST_NAME) {
+      const selectedVariant = (_a = options.variations.find((variant) => variant.id === CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID)) != null ? _a : options.variations.at(-1);
+      const value2 = {
+        result: selectedVariant,
+        variantAssigned: false
+      };
+      return value2;
+    }
+    const value = testVariations({
+      ...options,
+      context: this,
+      onLogMessage: (message) => __privateGet5(this, _mitt3).emit("log", message)
+    });
+    __privateMethod2(this, _Context_instances, emitTest_fn).call(this, {
+      name: options.name,
+      variantId: (_c = (_b = value.result) == null ? void 0 : _b.id) != null ? _c : void 0,
+      variantAssigned: value.variantAssigned,
+      control: (_e = (_d = value.result) == null ? void 0 : _d.control) != null ? _e : false,
+      compositionMetadata: options.compositionMetadata
+    });
+    return value;
+  }
+  /** Executes a personalized placement with a given set of variants */
+  personalize(options) {
+    var _a;
+    const algorithmName = (_a = options.algorithm) != null ? _a : TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM;
+    const algorithm = __privateGet5(this, _personalizationSelectionAlgorithms)[algorithmName];
+    if (!algorithm) {
+      __privateGet5(this, _mitt3).emit("log", ["warn", 304, { algorithm: algorithmName }]);
+      return {
+        personalized: false,
+        variations: []
+      };
+    }
+    const value = algorithm({
+      ...options,
+      context: this,
+      onLogMessage: (message) => __privateGet5(this, _mitt3).emit("log", message)
+    });
+    const previousPlacement = __privateGet5(this, _pzCache)[options.name];
+    const eventData = {
+      name: options.name,
+      variantIds: value.variations.map((variation) => ({
+        id: variation.id || "Unknown",
+        control: variation.control
+      })),
+      control: this.storage.data.controlGroup,
+      changed: true,
+      compositionMetadata: options.compositionMetadata
+    };
+    if (previousPlacement && dequal(eventData.variantIds, previousPlacement)) {
+      eventData.changed = false;
+    }
+    __privateGet5(this, _mitt3).emit("personalizationResult", eventData);
+    __privateGet5(this, _pzCache)[options.name] = eventData.variantIds;
+    return value;
+  }
+  /**
+   * Forgets the visitor's data and resets the Context to its initial state.
+   * @param fromAllDevices - for an identified user, whether to delete all their data (for the entire account) - true, or data for this device (sign out) - false
+   */
+  async forget(fromAllDevices) {
+    const previousCompositionMetadata = __privateGet5(this, _state).compositionMetadata;
+    __privateSet3(this, _state, {
+      compositionMetadata: previousCompositionMetadata
+    });
+    if (__privateGet5(this, _plugins)) {
+      for (let i = 0; i < __privateGet5(this, _plugins).length; i++) {
+        const plugin = __privateGet5(this, _plugins)[i];
+        if (!plugin.forget) {
+          continue;
+        }
+        await plugin.forget();
+      }
+    }
+    await this.storage.delete(fromAllDevices);
+  }
+  /**
+   * Computes server to client transition state.
+   *
+   * Removes state from server-to-client if it came in initial state (cookies) to avoid double tracking on the client.
+   */
+  getServerToClientTransitionState() {
+    const transitionState = {
+      quirks: this.storage.data.quirks,
+      ssv: __privateGet5(this, _scores),
+      tests: {},
+      personalizeVariants: this.storage.data.personalizeVariants,
+      commands: __privateGet5(this, _commands),
+      compositionMetadata: __privateGet5(this, _state).compositionMetadata
+    };
+    const allTests = this.storage.data.tests;
+    Object.entries(allTests).map(([testName, testValue]) => {
+      var _a, _b, _c;
+      if (((_c = (_b = (_a = this.storage.options.transitionStore) == null ? void 0 : _a.initialData) == null ? void 0 : _b.tests) == null ? void 0 : _c[testName]) !== allTests[testName] && transitionState.tests) {
+        transitionState.tests[testName] = testValue;
+      }
+    });
+    return transitionState;
+  }
+  /** @deprecated Internal API for test event processing; not for public use. */
+  internal_processTestEvent(event) {
+    if (event.variantId) {
+      this.setTestVariantId(event.name, event.variantId);
+      __privateMethod2(this, _Context_instances, emitTest_fn).call(this, event);
+    }
+  }
+  /** @deprecated Internal API for personalization event processing; not for public use. */
+  internal_processPersonalizationEvent(event) {
+    __privateGet5(this, _pzCache)[event.name] = event.variantIds;
+    __privateGet5(this, _mitt3).emit("personalizationResult", event);
+  }
+  /**
+   * Gets the current canvas data
+   */
+  getCompositionMetadata() {
+    return __privateGet5(this, _state).compositionMetadata;
+  }
+  /**
+   * Updates the canvas data and emits a canvasDataUpdated event
+   */
+  async updateCompositionMetadata(newData) {
+    const currentCanvas = __privateGet5(this, _state).compositionMetadata || {};
+    const updatedCanvas = { ...currentCanvas, ...newData };
+    if (!dequal(currentCanvas, updatedCanvas)) {
+      __privateSet3(this, _state, {
+        ...__privateGet5(this, _state),
+        compositionMetadata: updatedCanvas
+      });
+      __privateGet5(this, _mitt3).emit("canvasDataUpdated", updatedCanvas);
+      __privateGet5(this, _mitt3).emit("log", ["info", 4, "Canvas data updated"]);
+    }
+  }
+};
+_personalizationSelectionAlgorithms = /* @__PURE__ */ new WeakMap();
+_serverTransitionState = /* @__PURE__ */ new WeakMap();
+_scores = /* @__PURE__ */ new WeakMap();
+_state = /* @__PURE__ */ new WeakMap();
+_pzCache = /* @__PURE__ */ new WeakMap();
+_plugins = /* @__PURE__ */ new WeakMap();
+_commands = /* @__PURE__ */ new WeakMap();
+_requireConsentForPersonalization = /* @__PURE__ */ new WeakMap();
+_mitt3 = /* @__PURE__ */ new WeakMap();
+_Context_instances = /* @__PURE__ */ new WeakSet();
+emitTest_fn = function(event) {
+  __privateGet5(this, _mitt3).emit("testResult", event);
+};
+updateGoals_fn = async function(data) {
+  const goalCommands = this.manifest.computeGoals(data);
+  if (goalCommands.length !== 0) {
+    await this.storage.updateData(goalCommands);
+  }
+};
+updateComputedScores_fn = function(newData) {
+  const newScores = __privateMethod2(this, _Context_instances, calculateScores_fn).call(this, newData);
+  const newScoresHaveChanged = !dequal(newScores, __privateGet5(this, _scores));
+  if (newScoresHaveChanged) {
+    __privateSet3(this, _scores, newScores);
+    __privateMethod2(this, _Context_instances, updateGoals_fn).call(this, {
+      scores: __privateGet5(this, _scores),
+      quirks: void 0
+    });
+    __privateGet5(this, _mitt3).emit("scoresUpdated", newScores);
+    __privateGet5(this, _mitt3).emit("log", ["info", 3, newScores]);
+  }
+};
+calculateScores_fn = function(newData) {
+  var _a;
+  let newScores = { ...newData.scores };
+  for (const session in newData.sessionScores) {
+    newScores[session] = ((_a = newScores[session]) != null ? _a : 0) + newData.sessionScores[session];
+  }
+  newScores = this.manifest.computeAggregateDimensions(newScores);
+  return newScores;
+};
+var dc = (0, import_rfdc2.default)();
+var dc2 = (0, import_rfdc3.default)();
+
+// src/config/helpers.ts
+import config from "@uniformdev/next-app-router/config/resolved";
+var getDisabledDevTools = () => {
+  var _a;
+  if (typeof ((_a = config.context) == null ? void 0 : _a.disableDevTools) === "boolean") {
+    return config.context.disableDevTools;
+  }
+  return false;
+};
+var getDefaultConsent = () => {
+  if (typeof config.defaultConsent === "boolean") {
+    return config.defaultConsent;
+  }
+  return false;
+};
+var getQuirkSerialization = () => {
+  if (typeof config.quirkSerialization === "boolean") {
+    return config.quirkSerialization;
+  }
+  return true;
+};
+var getMiddlewareRuntimeCache = () => {
+  if (process.env.NODE_ENV === "development" && !process.env.RUNTIME_CACHE_ENDPOINT) {
+    return false;
+  }
+  if (typeof config.middlewareRuntimeCache === "boolean") {
+    return config.middlewareRuntimeCache;
+  }
+  return true;
+};
+var getDisableSwrMiddlewareCache = () => {
+  var _a;
+  if (typeof ((_a = config.experimental) == null ? void 0 : _a.disableSwrMiddlewareCache) === "boolean") {
+    return config.experimental.disableSwrMiddlewareCache;
+  }
+  return false;
+};
+
+// src/middleware/context/index.ts
+var createOnDemandContext = async (options) => {
+  var _a;
+  const manifest = await options.dataClient.getManifest({ source: (_a = options.source) != null ? _a : "middleware" });
+  if (!manifest) {
+    console.error("Uniform manifest not found, falling back to empty manifest");
+  }
+  return new OnDemandContext({
+    ...options,
+    manifest: manifest != null ? manifest : { project: {} },
+    defaultConsent: options.defaultConsent
+  });
+};
+var _options2;
+var OnDemandContext = class {
+  constructor(options) {
+    __privateAdd(this, _options2);
+    __privateSet(this, _options2, options);
+  }
+  async getContext() {
+    var _a, _b, _c;
+    if (!this._context) {
+      const uniformCookie = __privateGet(this, _options2).cookies.get(UNIFORM_DEFAULT_COOKIE_NAME);
+      const quirkCookie = __privateGet(this, _options2).cookies.get(UNIFORM_DEFAULT_QUIRK_COOKIE_NAME);
+      this._context = new Context({
+        manifest: __privateGet(this, _options2).manifest,
+        defaultConsent: (_a = __privateGet(this, _options2).defaultConsent) != null ? _a : getDefaultConsent(),
+        transitionStore: new CookieTransitionDataStore({
+          serverCookieValue: (_b = uniformCookie == null ? void 0 : uniformCookie.value) != null ? _b : "",
+          experimental_quirksEnabled: getQuirkSerialization(),
+          quirkCookieValue: (_c = quirkCookie == null ? void 0 : quirkCookie.value) != null ? _c : ""
+        })
+      });
+    }
+    return this._context;
+  }
+};
+_options2 = new WeakMap();
+
+// src/utils/quirks.ts
+var buildQuirksFromHeaders = (headers2) => {
+  const headerToQuirkKey = {
+    "x-vercel-ip-country": "vc-country",
+    "x-vercel-ip-country-region": "vc-region",
+    "x-vercel-ip-city": "vc-city"
+  };
+  return Object.entries(headerToQuirkKey).reduce((acc, [headerName, quirkKey]) => {
+    const value = headers2.get(headerName);
+    if (value) {
+      acc[quirkKey] = value;
+    }
+    return acc;
+  }, {});
+};
+
+// src/data/client.ts
+import { getCache, waitUntil } from "@vercel/functions";
+var MANIFEST_CACHE_KEY = "uniform-manifest";
+var DefaultDataClient = class {
+  async getManifest(options) {
+    const cache2 = options.source === "middleware" && getMiddlewareRuntimeCache() ? getCache() : null;
+    if (cache2) {
+      const cachedManifest = await cache2.get(MANIFEST_CACHE_KEY);
+      if (cachedManifest) {
+        return cachedManifest;
+      }
+    }
+    const manifest = await getManifest({
+      cache: isDevelopmentEnvironment() ? {
+        type: "no-cache",
+        bypassCache: true
+      } : {
+        type: "force-cache"
+      }
+    });
+    if (cache2) {
+      waitUntil(
+        (async () => {
+          await cache2.set(MANIFEST_CACHE_KEY, manifest, {
+            tags: generateManifestCacheTags()
+          });
+        })()
+      );
+    }
+    return manifest;
+  }
+  async getRouteFromApi({
+    route,
+    routeClient,
+    enableRuntimeCache,
+    disableSwrCache
+  }) {
+    const newCacheKey = `uniform-route-${route.state}-${route.releaseId}-${route.path}`;
+    const oldCacheKey = `uniform-route-old-${route.state}-${route.releaseId}-${route.path}`;
+    const cache2 = enableRuntimeCache ? getCache() : null;
+    const cacheNewRoute = async (result2) => {
+      if (cache2 && result2.type === "composition") {
+        const tags = generateRouteCacheTags({ path: route.path });
+        await cache2.set(newCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    const cacheOldRoute = async (result2) => {
+      if (cache2 && result2.type === "composition" && !disableSwrCache) {
+        const tags = generateRouteCacheTags({ path: route.path, old: true });
+        await cache2.set(oldCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    if (cache2) {
+      const [cachedRoute, oldCachedRoute] = await Promise.all([
+        cache2.get(newCacheKey),
+        disableSwrCache ? null : cache2.get(oldCacheKey)
+      ]);
+      if (cachedRoute) {
+        return cachedRoute;
+      }
+      if (oldCachedRoute) {
+        waitUntil(
+          (async () => {
+            const result2 = await routeClient.get(route);
+            await cacheNewRoute(result2);
+          })()
+        );
+        return oldCachedRoute;
+      }
+    }
+    const result = await routeClient.get(route);
+    waitUntil(
+      (async () => {
+        await Promise.all([
+          cacheNewRoute(result),
+          disableSwrCache ? Promise.resolve() : cacheOldRoute(result)
+        ]);
+      })()
+    );
+    return result;
+  }
+  async getRoute(options) {
+    if (options.source === "middleware") {
+      return this.getRouteMiddleware(options);
+    }
+    return this.getRoutePageState(options);
+  }
+  async enhanceRoute(_options3) {
+  }
+  async getRouteMiddleware(options) {
+    const routeClient = getRouteClient({
+      searchParams: options.searchParams,
+      draftModeEnabled: options.draftModeEnabled
+    });
+    const resolvedRoute = await this.getRouteFromApi({
+      source: "middleware",
+      route: options.route,
+      routeClient,
+      // The runtime cache is keyed on the route path. Development bypasses it so an author sees
+      // an edit right away, the same way the fetch cache is bypassed for development.
+      enableRuntimeCache: options.route.state === CANVAS_PUBLISHED_STATE && getMiddlewareRuntimeCache() && !isDevelopmentEnvironment(),
+      disableSwrCache: getDisableSwrMiddlewareCache()
+    });
+    if (resolvedRoute.type === "composition") {
+      await this.enhanceRoute({
+        source: "middleware",
+        parameters: options.route,
+        route: resolvedRoute,
+        routeClient,
+        keys: void 0
+      });
+    }
+    return {
+      route: resolvedRoute
+    };
+  }
+  async getRoutePageState(options) {
+    const shouldBypassCache = options.pageState.compositionState !== CANVAS_PUBLISHED_STATE || isDevelopmentEnvironment();
+    const routeClient = getRouteClient({
+      cache: shouldBypassCache ? {
+        type: "no-cache",
+        bypassCache: true
+      } : {
+        type: "force-cache"
+      }
+    });
+    const originalRoute = {
+      path: options.pageState.routePath,
+      state: options.pageState.compositionState,
+      dataSourceVariant: getDataSourceVariantFromRouteGetParams({}, options.pageState.compositionState),
+      withComponentIDs: true,
+      releaseId: options.pageState.releaseId,
+      locale: options.pageState.locale,
+      ignoreRedirects: shouldIgnoreRedirects({ state: options.pageState.compositionState })
+    };
+    const resolvedRoute = await this.getRouteFromApi({
+      source: "pageState",
+      route: originalRoute,
+      routeClient,
+      enableRuntimeCache: false,
+      disableSwrCache: false
+    });
+    if (resolvedRoute.type === "composition") {
+      await this.enhanceRoute({
+        source: "pageState",
+        parameters: originalRoute,
+        route: resolvedRoute,
+        routeClient,
+        keys: options.pageState.keys
+      });
+    }
+    return {
+      route: resolvedRoute
+    };
+  }
+};
+var expireMiddlewareCacheTag = async (tag) => {
+  const cache2 = getMiddlewareRuntimeCache() ? getCache() : null;
+  if (cache2) {
+    await cache2.expireTag(tag);
+  } else {
+    console.warn("Middleware cache is not enabled, cannot clear cache tag", tag);
+  }
+};
+
+// src/middleware/composition/evaluate/evaluateRunnables.ts
+import {
+  evaluatePersonalization,
+  evaluateTest
+} from "@uniformdev/next-app-router-shared";
+var evaluateRunnables = async ({
+  runnables,
+  context,
+  compositionContext,
+  isPrefetch
+}) => {
+  var _a;
+  const result = {
+    components: {},
+    rules: void 0
+  };
+  const runnablesToProcess = runnables.filter((item2) => item2.variantId === void 0);
+  let item;
+  while (item = runnablesToProcess.shift()) {
+    if (item.type === "test" && isPrefetch) {
+      continue;
+    }
+    if (item.type === "test") {
+      const testResult = evaluateTest({
+        context,
+        test: item.result,
+        compositionContext
+      });
+      if (testResult.index !== null) {
+        result.components[item._id] = {
+          indexes: [testResult.index]
+        };
+        if (testResult.componentId) {
+          const dependentRunnables = runnables.filter((r) => r.variantId === testResult.componentId);
+          runnablesToProcess.push(...dependentRunnables);
+        }
+      }
+    } else if (item.type === "personalization") {
+      const personalizationResult = evaluatePersonalization({
+        context,
+        personalization: item.result,
+        compositionContext
+      });
+      if (personalizationResult.indexes.length) {
+        result.components[item._id] = {
+          indexes: personalizationResult.indexes
+        };
+      }
+      if (personalizationResult.componentIds.length) {
+        const dependentRunnables = runnables.filter(
+          (r) => r.variantId && personalizationResult.componentIds.includes(r.variantId)
+        );
+        runnablesToProcess.push(...dependentRunnables);
+      }
+    } else if (item.type === "visibility") {
+      const rules = createQuirksVisibilityRule(context.quirks);
+      const isVisible = evaluateNodeVisibilityParameter({
+        rules,
+        parameter: item.rules
+      });
+      if (isVisible !== null) {
+        result.rules = (_a = result.rules) != null ? _a : {};
+        result.rules[item._id] = isVisible;
+      }
+    }
+  }
+  return result;
+};
+
+// src/data/extract/extractRunnables.ts
+import { getRuleId } from "@uniformdev/next-app-router-shared";
+
+// src/data/extract/extractPersonalization.ts
+import {
+  extractPersonalizationName
+} from "@uniformdev/next-app-router-shared";
+var extractPersonalization = ({
+  component
+}) => {
+  var _a, _b, _c;
+  const trackingEventName = extractPersonalizationName({ component });
+  const countParameter = (_a = component.parameters) == null ? void 0 : _a.count;
+  const algorithmParameter = (_b = component.parameters) == null ? void 0 : _b.algorithm;
+  const count = countParameter == null ? void 0 : countParameter.value;
+  const algorithm = algorithmParameter == null ? void 0 : algorithmParameter.value;
+  let parsedCount;
+  if (typeof count === "string") {
+    parsedCount = parseInt(count, 10);
+  } else if (typeof count !== "number") {
+    parsedCount = void 0;
+  } else {
+    parsedCount = count || 1;
+  }
+  const slot = ((_c = component.slots) == null ? void 0 : _c[CANVAS_PERSONALIZE_SLOT]) || [];
+  const componentVariations = mapSlotToPersonalizedVariations(
+    slot
+  ).map((variant, index) => {
+    const slotComponent = slot[index];
+    if (!slotComponent) {
+      throw new Error(`Slot component not found for index ${index}`);
+    }
+    return {
+      ...variant,
+      index,
+      componentId: slotComponent._id
+    };
+  });
+  return {
+    name: trackingEventName,
+    take: parsedCount,
+    variations: componentVariations,
+    algorithm
+  };
+};
+
+// src/data/extract/extractTest.ts
+import { extractTestName } from "@uniformdev/next-app-router-shared";
+var extractTest = ({ component }) => {
+  var _a;
+  const testName = extractTestName({ component });
+  const slot = ((_a = component.slots) == null ? void 0 : _a[CANVAS_TEST_SLOT]) || [];
+  const componentVariations = mapSlotToTestVariations(slot).map((variation, index) => {
+    const slotComponent = slot[index];
+    if (!slotComponent) {
+      throw new Error(`Slot component not found for index ${index}`);
+    }
+    return {
+      ...variation,
+      index,
+      componentId: slotComponent._id
+    };
+  });
+  return {
+    name: testName,
+    variations: componentVariations
+  };
+};
+
+// src/data/extract/extractRunnables.ts
+var findAncestorVariant = (ancestorsAndSelf) => {
+  for (let i = 0; i < ancestorsAndSelf.length; i++) {
+    const node = ancestorsAndSelf[i];
+    if (node.type === "slot" && (node.parentSlot === CANVAS_PERSONALIZE_SLOT || node.parentSlot === CANVAS_TEST_SLOT)) {
+      return node.node._id;
+    }
+  }
+  return void 0;
+};
+var extractRunnables = (composition) => {
+  const runnable = [];
+  walkNodeTree(composition, (node) => {
+    var _a, _b;
+    if (node.type === "component") {
+      const component = node.node;
+      const visibilityRules = (_b = (_a = component.parameters) == null ? void 0 : _a[CANVAS_VIZ_CONTROL_PARAM]) == null ? void 0 : _b.value;
+      if (component.type === CANVAS_TEST_TYPE) {
+        const test = extractTest({ component });
+        runnable.push({
+          _id: component._id,
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          type: "test",
+          result: test
+        });
+      } else if (component.type === CANVAS_PERSONALIZE_TYPE) {
+        const personalize = extractPersonalization({ component });
+        runnable.push({
+          type: "personalization",
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          _id: component._id,
+          result: personalize
+        });
+      }
+      if (visibilityRules) {
+        runnable.push({
+          type: "visibility",
+          _id: getRuleId(visibilityRules),
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          rules: visibilityRules
+        });
+      }
+    }
+  });
+  return runnable;
+};
+
+// src/data/evaluate/evaluatePageState.ts
+var evaluatePageState = async ({
+  composition,
+  matchedRoute,
+  dynamicInputs,
+  pageState,
+  context
+}) => {
+  const extracted = extractRunnables(composition);
+  const result = await evaluateRunnables({
+    runnables: extracted,
+    context,
+    isPrefetch: pageState.isPrefetch,
+    compositionContext: {
+      _id: composition._id,
+      type: composition.type,
+      state: pageState.compositionState,
+      isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
+      matchedRoute,
+      dynamicInputs,
+      pageState: {
+        ...pageState,
+        // empty for now, we need to pass composition metadata down to evaluateRunnables for Context events enrichment
+        components: {},
+        rules: void 0
+      }
+    }
+  });
+  const allComponentIds = extracted.filter((r) => r.type === "test" || r.type === "personalization").map((r) => r._id);
+  return {
+    ...result,
+    allComponentIds
+  };
+};
+
+// src/data/evaluate/evaluateDraftPageState.ts
+var REQUEST_ORIGIN_PLACEHOLDER = "http://uniform.local";
+var evaluateDraftPageState = async ({
+  pageState,
+  composition,
+  matchedRoute,
+  dynamicInputs,
+  dataClient
+}) => {
+  var _a;
+  const isPublished = pageState.compositionState === CANVAS_PUBLISHED_STATE;
+  const isAlreadyEvaluated = Object.keys(pageState.components).length > 0 || Boolean(pageState.rules);
+  if (isPublished || isAlreadyEvaluated) {
+    return pageState;
+  }
+  const [requestCookies, requestHeaders] = await Promise.all([cookies(), headers()]);
+  const onDemandContext = await createOnDemandContext({
+    source: "pageState",
+    cookies: requestCookies,
+    dataClient: dataClient != null ? dataClient : new DefaultDataClient(),
+    defaultConsent: pageState.defaultConsent
+  });
+  const context = await onDemandContext.getContext();
+  await context.update({
+    url: new URL((_a = pageState.requestPath) != null ? _a : pageState.routePath, REQUEST_ORIGIN_PLACEHOLDER),
+    cookies: requestCookies.getAll().reduce(
+      (acc, cookie) => {
+        acc[cookie.name] = cookie.value;
+        return acc;
+      },
+      {}
+    ),
+    // Same precedence as the middleware: header-derived quirks first, then the custom quirks
+    // the consumer passed to `handleUniformRoute`, which win on conflict.
+    quirks: {
+      ...buildQuirksFromHeaders(requestHeaders),
+      ...pageState.quirks
+    }
+  });
+  const { components, rules } = await evaluatePageState({
+    composition,
+    matchedRoute,
+    dynamicInputs,
+    pageState,
+    context
+  });
+  return {
+    ...pageState,
+    components,
+    rules
+  };
+};
+
+// src/components/ComponentProps.ts
+import {
+  resolveComponentFromPageState
+} from "@uniformdev/next-app-router-shared";
+var createComponentProps = ({
+  component,
+  parent,
+  isRoot,
+  slotName,
+  slotIndex,
+  slots,
+  pageState,
+  composition,
+  compositionContext
+}) => {
+  var _a, _b;
+  const parameters = (_a = component.parameters) != null ? _a : {};
+  const componentProps = {
+    parameters: Object.keys(parameters).reduce((acc, cur) => {
+      acc[cur] = {
+        parameterId: cur,
+        ...parameters[cur]
+      };
+      return acc;
+    }, {}),
+    component: {
+      _id: component._id,
+      _parentId: (_b = parent == null ? void 0 : parent._id) != null ? _b : null,
+      slotName,
+      slotIndex: isRoot ? void 0 : slotIndex
+    },
+    type: component.type,
+    variant: component.variant,
+    slots,
+    context: {
+      isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
+      _id: composition._id,
+      state: pageState.compositionState,
+      type: composition.type,
+      pageState,
+      matchedRoute: compositionContext.matchedRoute,
+      dynamicInputs: compositionContext.dynamicInputs
+    }
+  };
+  return componentProps;
+};
+var createPersonalizeComponentProps = ({
+  common,
+  componentId,
+  pageState
+}) => {
+  var _a;
+  const component = resolveComponentFromPageState({
+    pageState,
+    componentId
+  });
+  return {
+    ...common,
+    indexes: (_a = component == null ? void 0 : component.indexes) != null ? _a : []
+  };
+};
+var createTestComponentProps = ({
+  common,
+  componentId,
+  pageState,
+  test
+}) => {
+  var _a;
+  if (pageState.isPrefetch) {
+    return {
+      ...common,
+      index: void 0,
+      test
+    };
+  }
+  const component = resolveComponentFromPageState({
+    pageState,
+    componentId
+  });
+  const [testIndex] = (_a = component == null ? void 0 : component.indexes) != null ? _a : [];
+  return {
+    ...common,
+    index: testIndex,
+    test
   };
 };
 
@@ -3175,61 +6234,9 @@ var Test = ({ index, slots, test, component, context: compositionContext }) => {
   return createElement(Fragment, void 0, [indexToShow == null ? void 0 : indexToShow.component, eventElement]);
 };
 
-// src/components/UniformCompositionWrapper.tsx
-import { deserializeEvaluationResult } from "@uniformdev/next-app-router-shared";
-import React2, { Fragment as Fragment2, Suspense } from "react";
-var UniformCompositionWrapper = ({
-  code,
-  children
-}) => {
-  const data = deserializeEvaluationResult({ input: code });
-  const WrapperComponent = data.compositionState === CANVAS_EDITOR_STATE || data.compositionState === CANVAS_DRAFT_STATE ? Suspense : Fragment2;
-  return /* @__PURE__ */ React2.createElement(WrapperComponent, null, children);
-};
-
 // src/components/UniformContext.tsx
 import { DefaultUniformClientContext } from "@uniformdev/next-app-router-client";
-import React3 from "react";
-
-// src/config/helpers.ts
-import config from "@uniformdev/next-app-router/config/resolved";
-var getDisabledDevTools = () => {
-  var _a;
-  if (typeof ((_a = config.context) == null ? void 0 : _a.disableDevTools) === "boolean") {
-    return config.context.disableDevTools;
-  }
-  return false;
-};
-var getDefaultConsent = () => {
-  if (typeof config.defaultConsent === "boolean") {
-    return config.defaultConsent;
-  }
-  return false;
-};
-var getQuirkSerialization = () => {
-  if (typeof config.quirkSerialization === "boolean") {
-    return config.quirkSerialization;
-  }
-  return true;
-};
-var getMiddlewareRuntimeCache = () => {
-  if (process.env.NODE_ENV === "development" && !process.env.RUNTIME_CACHE_ENDPOINT) {
-    return false;
-  }
-  if (typeof config.middlewareRuntimeCache === "boolean") {
-    return config.middlewareRuntimeCache;
-  }
-  return true;
-};
-var getDisableSwrMiddlewareCache = () => {
-  var _a;
-  if (typeof ((_a = config.experimental) == null ? void 0 : _a.disableSwrMiddlewareCache) === "boolean") {
-    return config.experimental.disableSwrMiddlewareCache;
-  }
-  return false;
-};
-
-// src/components/UniformContext.tsx
+import React2 from "react";
 var UniformContext = async ({ clientContextComponent, result }) => {
   var _a;
   const manifest = await getManifest({
@@ -3245,7 +6252,7 @@ var UniformContext = async ({ clientContextComponent, result }) => {
   const disableDevTools = getDisabledDevTools();
   const defaultConsent = (_a = result == null ? void 0 : result.pageState.defaultConsent) != null ? _a : getDefaultConsent();
   const experimentalQuirkSerialization = getQuirkSerialization();
-  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
     ContextComponent,
     {
       manifest,
@@ -3259,18 +6266,18 @@ var UniformContext = async ({ clientContextComponent, result }) => {
 
 // src/components/VisibilityRulesWrapper.tsx
 import { VisibilityRulesWrapperClient } from "@uniformdev/next-app-router-client";
-import React4 from "react";
+import React3 from "react";
 var VisibilityRulesWrapper = ({
   parameter,
   initialIsVisible,
   children
 }) => {
-  return /* @__PURE__ */ React4.createElement(VisibilityRulesWrapperClient, { parameter, initialIsVisible }, children);
+  return /* @__PURE__ */ React3.createElement(VisibilityRulesWrapperClient, { parameter, initialIsVisible }, children);
 };
 
 // src/components/UniformComposition.tsx
 function UniformComposition({ code, ...props }) {
-  return /* @__PURE__ */ React5.createElement(UniformCompositionWrapper, { code }, /* @__PURE__ */ React5.createElement(UniformCompositionInner, { code, ...props }));
+  return /* @__PURE__ */ React4.createElement(UniformCompositionInner, { code, ...props });
 }
 async function UniformCompositionInner({
   code,
@@ -3281,7 +6288,7 @@ async function UniformCompositionInner({
   clientContextComponent,
   dataClient
 }) {
-  var _a, _b;
+  var _a, _b, _c;
   const result = await resolveRoute({
     code,
     dataClient
@@ -3289,8 +6296,15 @@ async function UniformCompositionInner({
   if (!(result == null ? void 0 : result.route) || ((_a = result == null ? void 0 : result.route) == null ? void 0 : _a.type) !== "composition") {
     notFound();
   }
-  const { pageState, route } = result;
+  const { route } = result;
   const composition = result.route.compositionApiResponse.composition;
+  const pageState = await evaluateDraftPageState({
+    pageState: result.pageState,
+    composition,
+    matchedRoute: route.matchedRoute,
+    dynamicInputs: (_b = route.dynamicInputs) != null ? _b : {},
+    dataClient
+  });
   applyEditableParameters({
     composition,
     state: route.compositionApiResponse.state
@@ -3302,7 +6316,7 @@ async function UniformCompositionInner({
     state: pageState.compositionState,
     isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
     matchedRoute: route.matchedRoute,
-    dynamicInputs: (_b = route.dynamicInputs) != null ? _b : {},
+    dynamicInputs: (_c = route.dynamicInputs) != null ? _c : {},
     pageState
   };
   const [resolved] = resolveComponents({
@@ -3318,7 +6332,7 @@ async function UniformCompositionInner({
     composition,
     compositionContext
   });
-  return /* @__PURE__ */ React5.createElement(React5.Fragment, null, resolved, /* @__PURE__ */ React5.createElement(Suspense2, null, /* @__PURE__ */ React5.createElement(
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, resolved, /* @__PURE__ */ React4.createElement(Suspense, null, /* @__PURE__ */ React4.createElement(
     UniformContext,
     {
       clientContextComponent,
@@ -3328,7 +6342,7 @@ async function UniformCompositionInner({
         route
       }
     }
-  )), (pageState.compositionState === CANVAS_EDITOR_STATE || pageState.compositionState === CANVAS_DRAFT_STATE) && /* @__PURE__ */ React5.createElement(UniformScript, null));
+  )), (pageState.compositionState === CANVAS_EDITOR_STATE || pageState.compositionState === CANVAS_DRAFT_STATE) && /* @__PURE__ */ React4.createElement(UniformScript, null));
 }
 var resolveComponents = ({
   target,
@@ -3406,7 +6420,7 @@ var resolveComponents = ({
     let element = null;
     if (wrapInSuspense) {
       element = createElement2(
-        Suspense2,
+        Suspense,
         {
           key,
           fallback: typeof wrapInSuspense === "boolean" || typeof (wrapInSuspense == null ? void 0 : wrapInSuspense.fallback) === "undefined" ? void 0 : createElement2(wrapInSuspense.fallback)
@@ -3477,7 +6491,7 @@ var resolveComponents = ({
       );
     }
     return createElement2(
-      Fragment3,
+      Fragment2,
       {
         key: !isRoot ? `${slotName}-${componentIndex}` : void 0
       },
@@ -3578,154 +6592,59 @@ var resolveSlots = ({
 
 // src/components/UniformPlayground.tsx
 import { draftMode } from "next/headers";
-import React6 from "react";
+import React5 from "react";
 
 // src/data/resolvePlaygroundRoute.ts
-import { deserializeEvaluationResult as deserializeEvaluationResult2 } from "@uniformdev/next-app-router-shared";
-var resolvePlaygroundRoute = async ({ code }) => {
-  const pageState = deserializeEvaluationResult2({ input: code });
-  const canvasClient = getCompositionDeliveryClient({
-    cache: {
-      type: "no-cache"
-    }
-  });
-  let composition = void 0;
-  try {
-    composition = await canvasClient.get({
-      compositionId: pageState.routePath,
-      state: pageState.compositionState,
-      withComponentIDs: true
-    });
-  } catch (e) {
-    console.warn(
-      `Failed to get composition ${pageState.routePath} with state ${pageState.compositionState}`,
-      e
-    );
-  }
-  if (!composition) {
-    return {
-      code,
-      pageState,
-      route: void 0
-    };
-  }
-  return {
-    code,
-    pageState,
-    route: {
-      type: "composition",
-      compositionApiResponse: composition,
-      matchedRoute: "composition"
-    }
-  };
-};
-
-// src/components/UniformPlayground.tsx
-var UniformPlayground = async ({ resolveRoute, ...rest }) => {
-  const isDraftMode = (await draftMode()).isEnabled;
-  if (!isDraftMode) {
-    return /* @__PURE__ */ React6.createElement("div", null, /* @__PURE__ */ React6.createElement("h1", null, "Playground is only available in draft mode"));
-  }
-  return /* @__PURE__ */ React6.createElement(UniformComposition, { ...rest, resolveRoute: resolvePlaygroundRoute });
-};
-
-// src/components/generateStaticParams.ts
-import { serializeEvaluationResult } from "@uniformdev/next-app-router-shared";
-
-// src/data/extract/extractRunnables.ts
-import { getRuleId } from "@uniformdev/next-app-router-shared";
-
-// src/data/extract/extractPersonalization.ts
-import {
-  extractPersonalizationName
-} from "@uniformdev/next-app-router-shared";
-var extractPersonalization = ({
-  component
-}) => {
-  var _a, _b, _c;
-  const trackingEventName = extractPersonalizationName({ component });
-  const countParameter = (_a = component.parameters) == null ? void 0 : _a.count;
-  const algorithmParameter = (_b = component.parameters) == null ? void 0 : _b.algorithm;
-  const count = countParameter == null ? void 0 : countParameter.value;
-  const algorithm = algorithmParameter == null ? void 0 : algorithmParameter.value;
-  let parsedCount;
-  if (typeof count === "string") {
-    parsedCount = parseInt(count, 10);
-  } else if (typeof count !== "number") {
-    parsedCount = void 0;
-  } else {
-    parsedCount = count || 1;
-  }
-  const slot = ((_c = component.slots) == null ? void 0 : _c[CANVAS_PERSONALIZE_SLOT]) || [];
-  const componentVariations = mapSlotToPersonalizedVariations(
-    slot
-  ).map((variant, index) => {
-    const slotComponent = slot[index];
-    if (!slotComponent) {
-      throw new Error(`Slot component not found for index ${index}`);
+import { deserializeEvaluationResult } from "@uniformdev/next-app-router-shared";
+var resolvePlaygroundRoute = async ({ code }) => {
+  const pageState = deserializeEvaluationResult({ input: code });
+  const canvasClient = getCompositionDeliveryClient({
+    cache: {
+      type: "no-cache"
     }
+  });
+  let composition = void 0;
+  try {
+    composition = await canvasClient.get({
+      compositionId: pageState.routePath,
+      state: pageState.compositionState,
+      withComponentIDs: true
+    });
+  } catch (e) {
+    console.warn(
+      `Failed to get composition ${pageState.routePath} with state ${pageState.compositionState}`,
+      e
+    );
+  }
+  if (!composition) {
     return {
-      ...variant,
-      index,
-      componentId: slotComponent._id
+      code,
+      pageState,
+      route: void 0
     };
-  });
+  }
   return {
-    name: trackingEventName,
-    take: parsedCount,
-    variations: componentVariations,
-    algorithm
+    code,
+    pageState,
+    route: {
+      type: "composition",
+      compositionApiResponse: composition,
+      matchedRoute: "composition"
+    }
   };
 };
 
-// src/data/extract/extractRunnables.ts
-var findAncestorVariant = (ancestorsAndSelf) => {
-  for (let i = 0; i < ancestorsAndSelf.length; i++) {
-    const node = ancestorsAndSelf[i];
-    if (node.type === "slot" && (node.parentSlot === CANVAS_PERSONALIZE_SLOT || node.parentSlot === CANVAS_TEST_SLOT)) {
-      return node.node._id;
-    }
+// src/components/UniformPlayground.tsx
+var UniformPlayground = async ({ resolveRoute, ...rest }) => {
+  const isDraftMode = (await draftMode()).isEnabled;
+  if (!isDraftMode) {
+    return /* @__PURE__ */ React5.createElement("div", null, /* @__PURE__ */ React5.createElement("h1", null, "Playground is only available in draft mode"));
   }
-  return void 0;
-};
-var extractRunnables = (composition) => {
-  const runnable = [];
-  walkNodeTree(composition, (node) => {
-    var _a, _b;
-    if (node.type === "component") {
-      const component = node.node;
-      const visibilityRules = (_b = (_a = component.parameters) == null ? void 0 : _a[CANVAS_VIZ_CONTROL_PARAM]) == null ? void 0 : _b.value;
-      if (component.type === CANVAS_TEST_TYPE) {
-        const test = extractTest({ component });
-        runnable.push({
-          _id: component._id,
-          variantId: findAncestorVariant(node.ancestorsAndSelf),
-          type: "test",
-          result: test
-        });
-      } else if (component.type === CANVAS_PERSONALIZE_TYPE) {
-        const personalize = extractPersonalization({ component });
-        runnable.push({
-          type: "personalization",
-          variantId: findAncestorVariant(node.ancestorsAndSelf),
-          _id: component._id,
-          result: personalize
-        });
-      }
-      if (visibilityRules) {
-        runnable.push({
-          type: "visibility",
-          _id: getRuleId(visibilityRules),
-          variantId: findAncestorVariant(node.ancestorsAndSelf),
-          rules: visibilityRules
-        });
-      }
-    }
-  });
-  return runnable;
+  return /* @__PURE__ */ React5.createElement(UniformComposition, { ...rest, resolveRoute: resolvePlaygroundRoute });
 };
 
 // src/components/generateStaticParams.ts
+import { serializeEvaluationResult } from "@uniformdev/next-app-router-shared";
 var createUniformPlaygroundStaticParams = async (options) => {
   var _a;
   const { paths } = options;
@@ -3978,173 +6897,6 @@ function generateAllGroupPermutations(groups) {
   return combineAcrossGroups(perGroupSelections);
 }
 
-// src/data/client.ts
-import { getCache, waitUntil } from "@vercel/functions";
-var MANIFEST_CACHE_KEY = "uniform-manifest";
-var DefaultDataClient = class {
-  async getManifest(options) {
-    const cache2 = options.source === "middleware" && getMiddlewareRuntimeCache() ? getCache() : null;
-    if (cache2) {
-      const cachedManifest = await cache2.get(MANIFEST_CACHE_KEY);
-      if (cachedManifest) {
-        return cachedManifest;
-      }
-    }
-    const manifest = await getManifest({
-      cache: isDevelopmentEnvironment() ? {
-        type: "no-cache",
-        bypassCache: true
-      } : {
-        type: "force-cache"
-      }
-    });
-    if (cache2) {
-      waitUntil(
-        (async () => {
-          await cache2.set(MANIFEST_CACHE_KEY, manifest, {
-            tags: generateManifestCacheTags()
-          });
-        })()
-      );
-    }
-    return manifest;
-  }
-  async getRouteFromApi({
-    route,
-    routeClient,
-    enableRuntimeCache,
-    disableSwrCache
-  }) {
-    const newCacheKey = `uniform-route-${route.state}-${route.releaseId}-${route.path}`;
-    const oldCacheKey = `uniform-route-old-${route.state}-${route.releaseId}-${route.path}`;
-    const cache2 = enableRuntimeCache ? getCache() : null;
-    const cacheNewRoute = async (result2) => {
-      if (cache2 && result2.type === "composition") {
-        const tags = generateRouteCacheTags({ path: route.path });
-        await cache2.set(newCacheKey, result2, {
-          tags
-        });
-      }
-    };
-    const cacheOldRoute = async (result2) => {
-      if (cache2 && result2.type === "composition" && !disableSwrCache) {
-        const tags = generateRouteCacheTags({ path: route.path, old: true });
-        await cache2.set(oldCacheKey, result2, {
-          tags
-        });
-      }
-    };
-    if (cache2) {
-      const [cachedRoute, oldCachedRoute] = await Promise.all([
-        cache2.get(newCacheKey),
-        disableSwrCache ? null : cache2.get(oldCacheKey)
-      ]);
-      if (cachedRoute) {
-        return cachedRoute;
-      }
-      if (oldCachedRoute) {
-        waitUntil(
-          (async () => {
-            const result2 = await routeClient.get(route);
-            await cacheNewRoute(result2);
-          })()
-        );
-        return oldCachedRoute;
-      }
-    }
-    const result = await routeClient.get(route);
-    waitUntil(
-      (async () => {
-        await Promise.all([
-          cacheNewRoute(result),
-          disableSwrCache ? Promise.resolve() : cacheOldRoute(result)
-        ]);
-      })()
-    );
-    return result;
-  }
-  async getRoute(options) {
-    if (options.source === "middleware") {
-      return this.getRouteMiddleware(options);
-    }
-    return this.getRoutePageState(options);
-  }
-  async enhanceRoute(_options) {
-  }
-  async getRouteMiddleware(options) {
-    const routeClient = getRouteClient({
-      searchParams: options.searchParams,
-      draftModeEnabled: options.draftModeEnabled
-    });
-    const resolvedRoute = await this.getRouteFromApi({
-      source: "middleware",
-      route: options.route,
-      routeClient,
-      enableRuntimeCache: options.route.state === CANVAS_PUBLISHED_STATE && getMiddlewareRuntimeCache(),
-      disableSwrCache: getDisableSwrMiddlewareCache()
-    });
-    if (resolvedRoute.type === "composition") {
-      await this.enhanceRoute({
-        source: "middleware",
-        parameters: options.route,
-        route: resolvedRoute,
-        routeClient,
-        keys: void 0
-      });
-    }
-    return {
-      route: resolvedRoute
-    };
-  }
-  async getRoutePageState(options) {
-    const shouldBypassCache = options.pageState.compositionState !== CANVAS_PUBLISHED_STATE || isDevelopmentEnvironment();
-    const routeClient = getRouteClient({
-      cache: shouldBypassCache ? {
-        type: "no-cache",
-        bypassCache: true
-      } : {
-        type: "force-cache"
-      }
-    });
-    const originalRoute = {
-      path: options.pageState.routePath,
-      state: options.pageState.compositionState,
-      dataSourceVariant: getDataSourceVariantFromRouteGetParams({}, options.pageState.compositionState),
-      withComponentIDs: true,
-      releaseId: options.pageState.releaseId,
-      locale: options.pageState.locale,
-      ignoreRedirects: shouldIgnoreRedirects({ state: options.pageState.compositionState })
-    };
-    const resolvedRoute = await this.getRouteFromApi({
-      source: "pageState",
-      route: originalRoute,
-      routeClient,
-      enableRuntimeCache: false,
-      disableSwrCache: false
-    });
-    if (resolvedRoute.type === "composition") {
-      await this.enhanceRoute({
-        source: "pageState",
-        parameters: originalRoute,
-        route: resolvedRoute,
-        routeClient,
-        keys: options.pageState.keys
-      });
-    }
-    return {
-      route: resolvedRoute
-    };
-  }
-};
-var expireMiddlewareCacheTag = async (tag) => {
-  const cache2 = getMiddlewareRuntimeCache() ? getCache() : null;
-  if (cache2) {
-    await cache2.expireTag(tag);
-  } else {
-    console.warn("Middleware cache is not enabled, cannot clear cache tag", tag);
-  }
-};
-
 // src/data/precomputeComposition.ts
 import {
   extractPersonalizationName as extractPersonalizationName2,
@@ -4218,12 +6970,12 @@ var precomputeComposition = ({
 };
 
 // src/data/resolveRouteFromCode.ts
-import { deserializeEvaluationResult as deserializeEvaluationResult3 } from "@uniformdev/next-app-router-shared";
+import { deserializeEvaluationResult as deserializeEvaluationResult2 } from "@uniformdev/next-app-router-shared";
 var resolveRouteFromCode = async ({
   code,
   dataClient: providedDataClient
 }) => {
-  const pageState = deserializeEvaluationResult3({ input: code });
+  const pageState = deserializeEvaluationResult2({ input: code });
   const dataClient = providedDataClient != null ? providedDataClient : new DefaultDataClient();
   const { route } = await dataClient.getRoute({
     source: "pageState",
@@ -4335,3 +7087,8 @@ export {
   resolveRouteFromCode,
   serverContext
 };
+/*! Bundled license information:
+
+js-cookie/dist/js.cookie.mjs:
+  (*! js-cookie v3.0.8 | MIT *)
+*/