@drip-apex/sdk 0.1.0 → 0.3.0

package/dist/flags.cjs

@@ -0,0 +1,1788 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/flags.ts
+var flags_exports = {};
+__export(flags_exports, {
+  defineFlagExperiment: () => defineFlagExperiment,
+  evaluateFlag: () => evaluateFlag,
+  evaluateFlagAssignment: () => evaluateFlagAssignment,
+  evaluateFlagValue: () => evaluateFlagValue
+});
+module.exports = __toCommonJS(flags_exports);
+
+// ../shared-runtime/src/bucketing.ts
+function murmurhash3_32_gc(key, seed = 0) {
+  let remainder = key.length & 3;
+  let bytes = key.length - remainder;
+  let h1 = seed;
+  let c1 = 3432918353;
+  let c2 = 461845907;
+  let i = 0;
+  while (i < bytes) {
+    let k12 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k12 = Math.imul(k12, c1);
+    k12 = k12 << 15 | k12 >>> 17;
+    k12 = Math.imul(k12, c2);
+    h1 ^= k12;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1 = Math.imul(h1, 5) + 3864292196;
+  }
+  let k1 = 0;
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+    case 1:
+      k1 ^= key.charCodeAt(i) & 255;
+      k1 = Math.imul(k1, c1);
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = Math.imul(k1, c2);
+      h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function hashToFloat(seed, value) {
+  const hash = murmurhash3_32_gc(seed + value, 1);
+  return hash % 1e4 / 1e4;
+}
+function variationHashToFloat(experimentId, value) {
+  return hashToFloat(`${experimentId}:variation`, value);
+}
+function inTrafficAllocation(hashValue, allocation = 1) {
+  if (allocation <= 0) return false;
+  if (allocation >= 1) return true;
+  return hashValue < allocation;
+}
+function chooseVariation(hashValue, weights) {
+  if (!weights.length) return -1;
+  const total = weights.reduce((sum, w) => sum + (w > 0 ? w : 0), 0);
+  if (total <= 0) return 0;
+  const n = hashValue * total;
+  let acc = 0;
+  for (let i = 0; i < weights.length; i++) {
+    acc += weights[i] > 0 ? weights[i] : 0;
+    if (n < acc) return i;
+  }
+  return weights.length - 1;
+}
+
+// src/define.ts
+var ExperimentDefinitionError = class extends Error {
+  constructor(slug, issues) {
+    super(`Invalid experiment "${slug}": ${issues.join("; ")}`);
+    this.name = "ExperimentDefinitionError";
+    this.issues = issues;
+  }
+};
+function validate(def) {
+  const issues = [];
+  if (!def.slug || typeof def.slug !== "string") {
+    issues.push("slug is required and must be a non-empty string");
+  } else if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(def.slug) && def.slug.length > 1) {
+    issues.push("slug must be lowercase alphanumeric with hyphens (e.g. 'hero-banner-v2')");
+  }
+  if (!def.name || typeof def.name !== "string") {
+    issues.push("name is required");
+  }
+  if (!Array.isArray(def.variations) || def.variations.length < 2) {
+    issues.push("at least 2 variations are required");
+  } else {
+    const controls = def.variations.filter((v) => v.isControl);
+    if (controls.length === 0) {
+      issues.push("exactly one variation must be marked as control (isControl: true)");
+    } else if (controls.length > 1) {
+      issues.push("only one variation can be the control");
+    }
+    const totalWeight = def.variations.reduce((sum, v) => sum + v.weight, 0);
+    if (Math.abs(totalWeight - 1) > 0.01) {
+      issues.push(`variation weights should sum to 1 (got ${totalWeight.toFixed(3)})`);
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const v of def.variations) {
+      if (!v.id) issues.push("every variation must have an id");
+      if (ids.has(v.id)) issues.push(`duplicate variation id: "${v.id}"`);
+      ids.add(v.id);
+      if (v.weight < 0 || v.weight > 1) issues.push(`variation "${v.id}" weight must be between 0 and 1`);
+    }
+  }
+  if (def.trafficAllocation !== void 0) {
+    if (def.trafficAllocation < 0 || def.trafficAllocation > 1) {
+      issues.push("trafficAllocation must be between 0 and 1");
+    }
+  }
+  if (def.goals) {
+    const goalIds = /* @__PURE__ */ new Set();
+    for (const g of def.goals) {
+      if (!g.id) issues.push("every goal must have an id");
+      if (goalIds.has(g.id)) issues.push(`duplicate goal id: "${g.id}"`);
+      goalIds.add(g.id);
+      if (g.type === "click" && !g.selector) {
+        issues.push(`click goal "${g.id}" requires a selector`);
+      }
+    }
+  }
+  return issues;
+}
+function defineExperiment(def) {
+  const issues = validate(def);
+  if (issues.length > 0) {
+    throw new ExperimentDefinitionError(def.slug ?? "(unnamed)", issues);
+  }
+  const experiment = {
+    id: def.slug,
+    // slug is used as the id for code-first experiments
+    slug: def.slug,
+    name: def.name,
+    trafficAllocation: def.trafficAllocation ?? 1,
+    targeting: def.targeting,
+    hashAttribute: def.hashAttribute,
+    variations: def.variations.map((v) => ({
+      id: v.id,
+      name: v.name,
+      weight: v.weight,
+      mutations: v.mutations ?? [],
+      value: v.value,
+      css: v.css,
+      js: v.js,
+      resetJs: v.resetJs,
+      externalCssUrl: v.externalCssUrl,
+      externalJsUrl: v.externalJsUrl,
+      isControl: v.isControl ?? false
+    })),
+    goals: def.goals?.map((g) => ({
+      id: g.id,
+      type: g.type,
+      selector: g.selector,
+      urlPattern: g.urlPattern,
+      countOnce: g.countOnce
+    }))
+  };
+  return Object.freeze(experiment);
+}
+
+// src/edge-runtime.ts
+function edgeRuntimeActive() {
+  return globalThis.__dripEdgeInit === true;
+}
+
+// src/hash.ts
+var UID_KEY = "drip_uid";
+var storageMode = "localStorage";
+var encodeStorageValues = false;
+var cookieDomain = "";
+var memoryUserId = null;
+function bytesToHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function generateId() {
+  if (globalThis.crypto && globalThis.crypto.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return bytesToHex(bytes);
+  }
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function encodeStoredValue(value) {
+  if (!encodeStorageValues) return value;
+  try {
+    return "b64:" + btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  } catch {
+    return value;
+  }
+}
+function decodeStoredValue(value) {
+  if (!value) return null;
+  if (!value.startsWith("b64:")) return value;
+  try {
+    const raw = value.slice(4).replace(/-/g, "+").replace(/_/g, "/");
+    const padded = raw + "=".repeat((4 - raw.length % 4) % 4);
+    return atob(padded);
+  } catch {
+    return null;
+  }
+}
+function browserStorage() {
+  try {
+    if (storageMode === "sessionStorage") return globalThis.sessionStorage ?? null;
+    if (storageMode === "localStorage") return globalThis.localStorage ?? null;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readStorage() {
+  if (storageMode === "memory") return memoryUserId;
+  if (storageMode === "cookie") return null;
+  try {
+    return decodeStoredValue(browserStorage()?.getItem(UID_KEY) || null);
+  } catch {
+    return null;
+  }
+}
+function writeStorage(value) {
+  if (storageMode === "memory") {
+    memoryUserId = value;
+    return;
+  }
+  if (storageMode === "cookie") return;
+  try {
+    browserStorage()?.setItem(UID_KEY, encodeStoredValue(value));
+  } catch {
+  }
+}
+function readCookie() {
+  if (!globalThis.document?.cookie) return null;
+  const match = globalThis.document.cookie.match(
+    new RegExp("(^| )" + UID_KEY + "=([^;]+)")
+  );
+  return match ? decodeStoredValue(decodeURIComponent(match[2])) : null;
+}
+function writeCookie(value) {
+  if (!globalThis.document) return;
+  const expires = new Date(Date.now() + 365 * 864e5).toUTCString();
+  const domain = cookieDomain ? "; domain=" + cookieDomain : "";
+  globalThis.document.cookie = UID_KEY + "=" + encodeURIComponent(encodeStoredValue(value)) + "; expires=" + expires + "; path=/" + domain;
+}
+function getUserId(provided) {
+  if (provided) return provided;
+  if (edgeRuntimeActive()) {
+    const edgeUserId = readCookie();
+    if (edgeUserId) {
+      if (readStorage() !== edgeUserId) writeStorage(edgeUserId);
+      return edgeUserId;
+    }
+  }
+  const existing = readStorage() || readCookie();
+  if (existing) return existing;
+  const created = generateId();
+  writeStorage(created);
+  if (storageMode !== "memory") writeCookie(created);
+  return created;
+}
+
+// src/data-layer-normalize.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function normalizeDataLayerEntry(item) {
+  if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+  const record = item;
+  if (typeof record.event === "string") {
+    return item;
+  }
+  if (record[0] !== "event" || typeof record[1] !== "string") return null;
+  const params = isPlainObject(record[2]) ? record[2] : {};
+  return { ...params, event: record[1] };
+}
+
+// src/runtime-tools.ts
+function noopCleanup() {
+  return () => {
+  };
+}
+function readDocument(env) {
+  return env.document ?? (typeof document !== "undefined" ? document : void 0);
+}
+function readWindow(env) {
+  return env.window ?? (typeof window !== "undefined" ? window : void 0);
+}
+function readLocation(env) {
+  return env.location ?? (typeof location !== "undefined" ? location : void 0);
+}
+function safeCallback(callback, value) {
+  try {
+    callback(value);
+  } catch {
+  }
+}
+function isElement(value) {
+  return typeof Element !== "undefined" && value instanceof Element;
+}
+function isDocument(value) {
+  return typeof Document !== "undefined" && value instanceof Document;
+}
+function collectMatches(root, selector) {
+  const matches = [];
+  if (isElement(root) && root.matches(selector)) {
+    matches.push(root);
+  }
+  try {
+    root.querySelectorAll(selector).forEach((element) => matches.push(element));
+  } catch {
+  }
+  return matches;
+}
+function observeRootFor(root, doc) {
+  if (isDocument(root)) {
+    return root.documentElement ?? root.body;
+  }
+  if (isElement(root)) return root;
+  return doc.documentElement ?? doc.body;
+}
+function normalizeInViewOptions(options) {
+  if (typeof options === "boolean") return { once: !options };
+  return options ?? {};
+}
+function normalizeMatcher(matcher) {
+  return Array.isArray(matcher) ? matcher : Object.entries(matcher);
+}
+function matchesDataLayerEntry(entry, matcher) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const record = entry;
+  return normalizeMatcher(matcher).every(([key, expected]) => {
+    if (expected instanceof RegExp) {
+      return expected.test(String(record[key] ?? ""));
+    }
+    return record[key] === expected;
+  });
+}
+function createApexRuntimeTools(env = {}) {
+  const tools = {
+    waitForElement(selector, callback, options = {}) {
+      const doc = readDocument(env);
+      if (!doc || !selector.trim()) return noopCleanup();
+      const root = options.root ?? doc;
+      const seen = /* @__PURE__ */ new WeakSet();
+      let active = true;
+      let observer = null;
+      let timeoutId = null;
+      const stop = () => {
+        active = false;
+        observer?.disconnect();
+        observer = null;
+        if (timeoutId !== null) {
+          readWindow(env)?.clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+      const handle = (scope) => {
+        if (!active) return;
+        for (const element of collectMatches(scope, selector)) {
+          if (seen.has(element)) continue;
+          seen.add(element);
+          safeCallback(callback, element);
+          if (options.once !== false) {
+            stop();
+            return;
+          }
+        }
+      };
+      handle(root);
+      if (!active || typeof MutationObserver === "undefined") return stop;
+      const observeTarget = observeRootFor(root, doc);
+      if (!observeTarget) return stop;
+      observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          mutation.addedNodes.forEach((node) => {
+            if (isElement(node)) handle(node);
+          });
+        }
+      });
+      observer.observe(observeTarget, { childList: true, subtree: true });
+      if (options.timeoutMs && options.timeoutMs > 0) {
+        timeoutId = readWindow(env)?.setTimeout(stop, options.timeoutMs) ?? null;
+      }
+      return stop;
+    },
+    elementIsInView(selector, callback, rawOptions) {
+      const doc = readDocument(env);
+      const win = readWindow(env);
+      if (!doc || !win || !selector.trim()) return noopCleanup();
+      const options = normalizeInViewOptions(rawOptions);
+      const once = options.once !== false;
+      const observed = /* @__PURE__ */ new WeakSet();
+      const cleanups = [];
+      let observer = null;
+      const stop = () => {
+        observer?.disconnect();
+        observer = null;
+        cleanups.splice(0).forEach((cleanup) => cleanup());
+      };
+      if (typeof IntersectionObserver === "undefined") {
+        return tools.waitForElement(
+          selector,
+          (element) => {
+            const rect = element.getBoundingClientRect();
+            const inView = rect.width > 0 && rect.height > 0 && rect.bottom >= 0 && rect.right >= 0 && rect.top <= win.innerHeight && rect.left <= win.innerWidth;
+            if (inView) safeCallback(callback, element);
+          },
+          { once, timeoutMs: options.timeoutMs }
+        );
+      }
+      observer = new IntersectionObserver(
+        (entries) => {
+          for (const entry of entries) {
+            if (!entry.isIntersecting) continue;
+            safeCallback(callback, entry.target);
+            if (once) observer?.unobserve(entry.target);
+          }
+        },
+        {
+          root: isDocument(options.root) ? null : options.root ?? null,
+          rootMargin: options.rootMargin,
+          threshold: options.threshold ?? 1
+        }
+      );
+      cleanups.push(
+        tools.waitForElement(
+          selector,
+          (element) => {
+            if (observed.has(element)) return;
+            observed.add(element);
+            observer?.observe(element);
+          },
+          { once: false, timeoutMs: options.timeoutMs }
+        )
+      );
+      return stop;
+    },
+    domChanged(callback, options = {}) {
+      const doc = readDocument(env);
+      const win = readWindow(env);
+      if (!doc || typeof MutationObserver === "undefined") return noopCleanup();
+      const root = options.root ?? doc.documentElement ?? doc.body;
+      if (!root) return noopCleanup();
+      const debounceMs = Math.max(0, options.debounceMs ?? 50);
+      let pending = [];
+      let timeoutId = null;
+      const flush = () => {
+        timeoutId = null;
+        const mutations = pending;
+        pending = [];
+        safeCallback(callback, mutations);
+      };
+      const observer = new MutationObserver((mutations) => {
+        pending.push(...mutations);
+        if (debounceMs === 0) {
+          flush();
+          return;
+        }
+        if (timeoutId !== null) return;
+        timeoutId = win?.setTimeout(flush, debounceMs) ?? null;
+      });
+      observer.observe(root, { childList: true, subtree: options.subtree !== false });
+      return () => {
+        observer.disconnect();
+        if (timeoutId !== null) win?.clearTimeout(timeoutId);
+      };
+    },
+    domLoaded(callback) {
+      const doc = readDocument(env);
+      if (!doc || doc.readyState !== "loading") {
+        safeCallback(callback, void 0);
+        return noopCleanup();
+      }
+      const handler = () => safeCallback(callback, void 0);
+      doc.addEventListener("DOMContentLoaded", handler, { once: true });
+      return () => doc.removeEventListener("DOMContentLoaded", handler);
+    },
+    waitForDataLayer(matcher, callback, options = {}) {
+      const win = readWindow(env);
+      if (!win) return noopCleanup();
+      const layerName = options.layerName || "dataLayer";
+      const layerHost = win;
+      const layer = Array.isArray(layerHost[layerName]) ? layerHost[layerName] : [];
+      layerHost[layerName] = layer;
+      const originalPush = layer.push;
+      let active = true;
+      let timeoutId = null;
+      const process = (entry) => {
+        if (!active) return;
+        const normalized = normalizeDataLayerEntry(entry);
+        const rawRecord = entry && typeof entry === "object" && !Array.isArray(entry) ? entry : null;
+        const candidate = normalized ?? (rawRecord && typeof rawRecord[0] !== "string" ? rawRecord : null);
+        if (!candidate || !matchesDataLayerEntry(candidate, matcher)) return;
+        safeCallback(callback, candidate);
+        if (options.once !== false) cleanup();
+      };
+      const cleanup = () => {
+        active = false;
+        if (layer.push === wrappedPush) layer.push = originalPush;
+        if (timeoutId !== null) {
+          win.clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+      const wrappedPush = function(...items) {
+        const result = originalPush.apply(layer, items);
+        items.forEach(process);
+        return result;
+      };
+      layer.slice(Math.max(0, layer.length - 50)).forEach(process);
+      if (active) layer.push = wrappedPush;
+      if (options.timeoutMs && options.timeoutMs > 0) {
+        timeoutId = win.setTimeout(cleanup, options.timeoutMs);
+      }
+      return cleanup;
+    },
+    track(type, data) {
+      env.track?.(type, data);
+    },
+    trackGoal(goalId, data) {
+      env.trackGoal?.(goalId, data);
+    },
+    signal(key, value, ttlDays) {
+      env.signal?.(key, value, ttlDays);
+    },
+    redirect(target) {
+      const loc = readLocation(env);
+      if (!loc || !target.trim()) return;
+      loc.assign(new URL(target, loc.href).toString());
+    },
+    reInit(forceReapply) {
+      return env.reInit?.(forceReapply);
+    },
+    get(key) {
+      if (key === "tools") return tools;
+      return env.get?.(key);
+    }
+  };
+  return tools;
+}
+
+// ../event-schema/src/targeting-core.ts
+function isRegexOuterQuantifierStart(pattern, index) {
+  return pattern[index] !== "?" && isRegexQuantifierStart(pattern, index);
+}
+function isRegexQuantifierStart(pattern, index) {
+  const char = pattern[index];
+  if (char === "*" || char === "+" || char === "?") return true;
+  if (char !== "{") return false;
+  const end = pattern.indexOf("}", index + 1);
+  if (end === -1) return false;
+  return /^\{\d+(?:,\d*)?\}$/.test(pattern.slice(index, end + 1));
+}
+function isSafeRegexPattern(pattern) {
+  if (!pattern || pattern.length > MAX_PATTERN_LENGTH) return false;
+  const groups = [];
+  let escaped = false;
+  let inClass = false;
+  let hasBackreference = false;
+  let hasQuantifiedGroup = false;
+  let hasQuantifierInGroup = false;
+  let hasQuantifiedBackreference = false;
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      const numericBackreference = /^[1-9]$/.test(pattern[index + 1] ?? "");
+      const namedBackreference = pattern[index + 1] === "k" ? pattern.slice(index + 2).match(/^<[^>]+>/)?.[0] : void 0;
+      if (numericBackreference || namedBackreference) {
+        hasBackreference = true;
+        const backreferenceEnd = numericBackreference ? index + 2 : index + 2 + namedBackreference.length;
+        if (isRegexQuantifierStart(pattern, backreferenceEnd)) {
+          hasQuantifiedBackreference = true;
+        }
+        index = backreferenceEnd - 1;
+      } else {
+        escaped = true;
+      }
+      continue;
+    }
+    if (char === "[") {
+      inClass = true;
+      continue;
+    }
+    if (char === "]") {
+      inClass = false;
+      continue;
+    }
+    if (inClass) continue;
+    if (char === "(") {
+      groups.push({ hasAlternation: false, hasQuantifier: false });
+      continue;
+    }
+    if (char === "|") {
+      const current = groups[groups.length - 1];
+      if (current) current.hasAlternation = true;
+      continue;
+    }
+    if (isRegexQuantifierStart(pattern, index)) {
+      if (char === "?" && pattern[index - 1] === "(") continue;
+      const current = groups[groups.length - 1];
+      if (current) {
+        current.hasQuantifier = true;
+        hasQuantifierInGroup = true;
+      }
+      if (char === "{") index = pattern.indexOf("}", index + 1);
+      continue;
+    }
+    if (char === ")") {
+      const group = groups.pop();
+      if (!group) return false;
+      const quantified = isRegexOuterQuantifierStart(pattern, index + 1);
+      hasQuantifiedGroup = hasQuantifiedGroup || quantified;
+      if (quantified && (group.hasQuantifier || group.hasAlternation))
+        return false;
+      const parent = groups[groups.length - 1];
+      if (parent) {
+        parent.hasQuantifier = parent.hasQuantifier || group.hasQuantifier || quantified;
+        parent.hasAlternation = parent.hasAlternation || group.hasAlternation;
+      }
+    }
+  }
+  return !escaped && !inClass && groups.length === 0 && !(hasBackreference && (hasQuantifiedGroup || hasQuantifierInGroup || hasQuantifiedBackreference));
+}
+var MAX_PATTERN_LENGTH = 1024;
+var MAX_CACHE_ENTRIES = 256;
+var regexCache = /* @__PURE__ */ new Map();
+function cacheRegex(pattern, compiled) {
+  if (!regexCache.has(pattern) && regexCache.size >= MAX_CACHE_ENTRIES) {
+    const oldest = regexCache.keys().next().value;
+    if (oldest !== void 0) regexCache.delete(oldest);
+  }
+  regexCache.set(pattern, compiled);
+}
+function safeRegexTestDetailed(pattern, input, executeUnsafePatterns) {
+  if (!pattern || pattern.length > MAX_PATTERN_LENGTH) return { matched: false };
+  if (!executeUnsafePatterns && !isSafeRegexPattern(pattern)) {
+    try {
+      new RegExp(pattern);
+      return { matched: false, indeterminate: true };
+    } catch {
+      return { matched: false };
+    }
+  }
+  if (regexCache.has(pattern)) {
+    const cached = regexCache.get(pattern);
+    return { matched: cached ? cached.test(input) : false };
+  }
+  let compiled = null;
+  try {
+    compiled = new RegExp(pattern);
+  } catch {
+    compiled = null;
+  }
+  cacheRegex(pattern, compiled);
+  return { matched: compiled ? compiled.test(input) : false };
+}
+function safeRegexTest(pattern, input) {
+  return safeRegexTestDetailed(pattern, input, true).matched;
+}
+function evalSimpleUrlPart(actual, pattern, isPath) {
+  try {
+    let escaped = pattern.replace(/[*.+?^${}()|[\]\\]/g, "\\$&").replace(/_____/g, ".*");
+    if (isPath) escaped = "\\/?" + escaped.replace(/(^\/|\/$)/g, "") + "\\/?";
+    return new RegExp("^" + escaped + "$", "i").test(actual);
+  } catch {
+    return false;
+  }
+}
+function evalSimpleUrlTarget(actual, pattern) {
+  try {
+    const expected = new URL(pattern.replace(/^([^:/?]*)\./i, "https://$1.").replace(/\*/g, "_____"), "https://_____");
+    const components = [
+      [actual.host, expected.host, false],
+      [actual.pathname, expected.pathname, true]
+    ];
+    if (expected.hash) components.push([actual.hash, expected.hash, false]);
+    expected.searchParams.forEach((value, key) => components.push([actual.searchParams.get(key) || "", value, false]));
+    return !components.some(([value, expectedValue, path]) => !evalSimpleUrlPart(value, expectedValue, path));
+  } catch {
+    return false;
+  }
+}
+function unescapeRegexLiteral(value) {
+  return value.replace(/\\([.*+?^${}()|[\]\\\/])/g, "$1");
+}
+function evaluateUrlRuleDetailed(url, rule, options) {
+  const executeUnsafePatterns = options?.executeUnsafePatterns !== false;
+  try {
+    const parsed = new URL(url, "https://_");
+    const matchType = rule.matchType ?? rule.match_type;
+    if (matchType === "contains") {
+      const actual = parsed.href.toLowerCase();
+      const pattern = rule.pattern.toLowerCase();
+      return { matched: actual.includes(pattern) || actual.includes(unescapeRegexLiteral(pattern)) };
+    }
+    if (rule.type === "regex") {
+      const escaped = rule.pattern.replace(/([^\\])\//g, "$1\\/");
+      const absolute = safeRegexTestDetailed(escaped, parsed.href, executeUnsafePatterns);
+      if (absolute.matched || absolute.indeterminate) return absolute;
+      return safeRegexTestDetailed(escaped, parsed.href.substring(parsed.origin.length), executeUnsafePatterns);
+    }
+    return { matched: evalSimpleUrlTarget(parsed, rule.pattern) };
+  } catch {
+    return { matched: false };
+  }
+}
+function evaluateUrlRule(url, rule) {
+  return evaluateUrlRuleDetailed(url, rule).matched;
+}
+function urlRuleExplicitlyNamesHost(rule) {
+  const pattern = unescapeRegexLiteral(rule.pattern.trim()).replace(/^\^/, "");
+  return /^\(?[a-z][a-z0-9+.-]*\??:\/\//i.test(pattern) || /^\/\/[^/]/.test(pattern) || /^(?:\*\.)?[^/?#\s*]+\.[^/?#\s]+(?::\d+)?(?:[/?#]|$)/i.test(pattern);
+}
+function normalizeUrlRule(value) {
+  if (typeof value === "string") {
+    const pattern2 = value.trim();
+    return pattern2 ? { type: "simple", pattern: pattern2, include: true } : null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  const candidate = raw.pattern ?? raw.value ?? raw.url ?? raw.path;
+  const pattern = typeof candidate === "string" ? candidate.trim() : "";
+  if (!pattern) return null;
+  const rawMatch = raw.matchType ?? raw.match_type;
+  const matchType = ["exact", "contains", "wildcard", "regex"].includes(String(rawMatch)) ? rawMatch : raw.type === "url_contains" ? "contains" : void 0;
+  return {
+    type: raw.type === "regex" || raw.type === "url_regex" ? "regex" : "simple",
+    pattern,
+    include: typeof raw.include === "boolean" ? raw.include : true,
+    ...matchType ? { matchType } : {}
+  };
+}
+function normalizeUrlRules(targeting) {
+  if (!targeting || typeof targeting !== "object" || Array.isArray(targeting)) return [];
+  const raw = targeting;
+  const urls = Array.isArray(raw.url) ? raw.url : raw.url == null ? [] : [raw.url];
+  return urls.concat(Array.isArray(raw.rules) ? raw.rules : []).map(normalizeUrlRule).filter((rule) => Boolean(rule));
+}
+function stringValues(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item).trim()).filter(Boolean);
+  if (value == null) return [];
+  return [String(value)];
+}
+function meaningful(value) {
+  if (value == null) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value !== "string" || value.trim().length > 0;
+}
+function compareNumber(actual, expected, predicate) {
+  const a = Number(Array.isArray(actual) ? actual[0] : actual);
+  const b = Number(Array.isArray(expected) ? expected[0] : expected);
+  return Number.isFinite(a) && Number.isFinite(b) && predicate(a, b);
+}
+function wildcard(pattern) {
+  return "^" + pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
+}
+function matchSegmentConditionValues(condition, actual, expected = condition.value) {
+  const actualValues = stringValues(actual);
+  const expectedValues = stringValues(expected);
+  const first = expectedValues[0] ?? "";
+  switch (condition.operator) {
+    case "equals":
+      return actualValues.some((value) => value === String(expected ?? ""));
+    case "not_equals":
+      return !actualValues.some((value) => value === String(expected ?? ""));
+    case "contains":
+      return actualValues.some((value) => expectedValues.length > 1 ? expectedValues.includes(value) : value.includes(first));
+    case "not_contains":
+      return !actualValues.some((value) => expectedValues.length > 1 ? expectedValues.includes(value) : value.includes(first));
+    case "starts_with":
+      return actualValues.some((value) => value.startsWith(first));
+    case "ends_with":
+      return actualValues.some((value) => value.endsWith(first));
+    case "is_set":
+      return meaningful(actual);
+    case "is_empty":
+      return !meaningful(actual);
+    case "in":
+      return actualValues.some((value) => expectedValues.includes(value));
+    case "not_in":
+      return !actualValues.some((value) => expectedValues.includes(value));
+    case "matches_wildcard":
+      return actualValues.some((value) => safeRegexTest(wildcard(first), value));
+    case "matches_regex":
+      return actualValues.some((value) => safeRegexTest(first, value));
+    case "greater_than":
+      return compareNumber(actual, expected, (a, b) => a > b);
+    case "greater_than_or_equal":
+      return compareNumber(actual, expected, (a, b) => a >= b);
+    case "less_than":
+      return compareNumber(actual, expected, (a, b) => a < b);
+    case "less_than_or_equal":
+      return compareNumber(actual, expected, (a, b) => a <= b);
+    default:
+      return false;
+  }
+}
+
+// src/signals.ts
+var STORE_KEY = "drip_signals_v1";
+var VISITOR_SEEN_KEY = "drip_visitor_seen_v1";
+var DEFAULT_TTL_DAYS = 30;
+var MAX_ARRAY_LENGTH = 24;
+var MAX_VALUE_BYTES = 4096;
+var runtimeSignals = {};
+var signalSources = {};
+var signalPersistenceAllowed = () => true;
+function now() {
+  return Date.now();
+}
+function ttlMs(days) {
+  return Math.max(1, days) * 86400 * 1e3;
+}
+function canUseLocalStorage() {
+  if (!canPersistSignals()) return false;
+  try {
+    if (typeof localStorage === "undefined") return false;
+    const key = "__drip_signal_test__";
+    localStorage.setItem(key, "1");
+    localStorage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function canPersistSignals() {
+  try {
+    return signalPersistenceAllowed() === true;
+  } catch {
+    return false;
+  }
+}
+function readStore() {
+  if (!canUseLocalStorage()) return {};
+  try {
+    const parsed = JSON.parse(localStorage.getItem(STORE_KEY) || "{}");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeStore(store) {
+  if (!canUseLocalStorage()) return;
+  try {
+    localStorage.setItem(STORE_KEY, JSON.stringify(store));
+  } catch {
+  }
+}
+function normalizeValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string") return value.slice(0, 1e3);
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item).trim()).filter(Boolean).slice(0, MAX_ARRAY_LENGTH);
+  }
+  if (value && typeof value === "object") {
+    try {
+      const json = JSON.stringify(value);
+      if (json.length > MAX_VALUE_BYTES) return void 0;
+      return JSON.parse(json);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function compactStore(store) {
+  const ts = now();
+  const next = {};
+  for (const [key, entry] of Object.entries(store)) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.expiresAt && entry.expiresAt <= ts) continue;
+    next[key] = entry;
+  }
+  return next;
+}
+function setSignal(key, value, ttlDays = DEFAULT_TTL_DAYS, source = "manual") {
+  if (!canPersistSignals()) return;
+  const normalized = normalizeValue(value);
+  if (normalized === void 0) return;
+  const store = compactStore(readStore());
+  store[key] = {
+    value: normalized,
+    updatedAt: now(),
+    expiresAt: now() + ttlMs(ttlDays)
+  };
+  writeStore(store);
+  signalSources[key] = source;
+}
+function getSignals(options = {}) {
+  const store = compactStore(readStore());
+  if (options.markVisitorSeen !== false) writeStore(store);
+  const signals = {};
+  for (const [key, entry] of Object.entries(store)) {
+    signals[key] = entry.value;
+  }
+  Object.assign(signals, runtimeSignals);
+  if (options.markVisitorSeen !== false && canPersistSignals()) {
+    try {
+      const seen = localStorage.getItem(VISITOR_SEEN_KEY) === "1";
+      signals["visitor.returning"] = seen;
+      localStorage.setItem(VISITOR_SEEN_KEY, "1");
+    } catch {
+    }
+  }
+  return signals;
+}
+function prependUnique(values, next) {
+  const clean = next.trim();
+  if (!clean) return values;
+  return [clean, ...values.filter((value) => value !== clean)].slice(0, MAX_ARRAY_LENGTH);
+}
+function readStringArray(key) {
+  const value = getSignals({ markVisitorSeen: false })[key];
+  return Array.isArray(value) ? value.map((item) => String(item)) : [];
+}
+function rememberProduct(product, ttlDays = DEFAULT_TTL_DAYS) {
+  const id = product.id == null ? "" : String(product.id);
+  const handle = product.handle ? String(product.handle) : "";
+  const productType = product.type ? String(product.type) : "";
+  if (id) {
+    setSignal("recently_viewed.product_ids", prependUnique(readStringArray("recently_viewed.product_ids"), id), ttlDays);
+  }
+  if (handle) {
+    setSignal("recently_viewed.product_handles", prependUnique(readStringArray("recently_viewed.product_handles"), handle), ttlDays);
+  }
+  if (productType) {
+    setSignal(
+      "recently_viewed.product_types",
+      prependUnique(readStringArray("recently_viewed.product_types"), productType),
+      ttlDays
+    );
+  }
+  if (product.tags?.length) {
+    const existing = readStringArray("recently_viewed.product_tags");
+    const next = product.tags.reduce((acc, tag) => prependUnique(acc, String(tag)), existing);
+    setSignal("recently_viewed.product_tags", next, ttlDays);
+  }
+  setSignal("recently_viewed.last_product", {
+    id: id || void 0,
+    handle: handle || void 0,
+    title: product.title || void 0,
+    type: productType || void 0,
+    vendor: product.vendor || void 0,
+    price: product.price ?? void 0
+  }, ttlDays);
+}
+
+// src/targeting.ts
+var FAIL_CLOSED_TARGETING_ATTRIBUTE = "apex.internal.invalid_stored_targeting";
+function normalizeRuntimeUrlRules(targeting) {
+  return normalizeUrlRules(targeting);
+}
+function normalizedHttpOrigins(value) {
+  const origins = /* @__PURE__ */ new Set();
+  for (const candidate of Array.isArray(value) ? value : value ? [value] : []) {
+    try {
+      const parsed = new URL(candidate);
+      if (/^https?:$/.test(parsed.protocol)) origins.add(parsed.origin);
+    } catch {
+    }
+  }
+  return origins;
+}
+function matchUrlRules(url, rules, hostAgnosticIncludeOrigin) {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+  for (const rule of rules) {
+    const match = evalUrlRuleForIncludeOrigin(url, rule, hostAgnosticIncludeOrigin);
+    if (rule.include === false) {
+      if (match) return false;
+    } else {
+      hasInclude = true;
+      if (match) included = true;
+    }
+  }
+  return included || !hasInclude;
+}
+function evalUrlRuleForIncludeOrigin(url, rule, origins) {
+  const allowed = normalizedHttpOrigins(origins);
+  let origin = "";
+  try {
+    origin = new URL(url, "https://_").origin;
+  } catch {
+  }
+  return (rule.include === false || !allowed.size || urlRuleExplicitlyNamesHost(rule) || allowed.has(origin)) && evaluateUrlRule(url, rule);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function jsErrorReason(error) {
+  const message = errorMessage(error);
+  return message ? `js_error: ${message}` : "js_error";
+}
+function evaluatePageAdvancedConditionResult(rule, ctx) {
+  const code = rule.advancedCondition?.code?.trim();
+  if (!code) return { matched: true };
+  try {
+    const url = new URL(
+      ctx.url,
+      typeof location !== "undefined" ? location.origin : "https://_"
+    );
+    const fn = new Function(
+      "context",
+      `"use strict";const attributes=context.attributes;const document=context.document;const location=context.location;const url=context.url;const window=context.window;return Boolean((function(){${/\breturn\b|;\s*$|\bthrow\b/.test(code) ? code : `return (${code});`}}).call(window));`
+    );
+    const matched = Boolean(fn({
+      attributes: ctx.attributes,
+      document: typeof document !== "undefined" ? document : void 0,
+      location: typeof location !== "undefined" ? location : void 0,
+      url,
+      window: typeof window !== "undefined" ? window : void 0
+    }));
+    return { matched, reason: matched ? void 0 : "js_false" };
+  } catch (error) {
+    return { matched: false, reason: jsErrorReason(error), error };
+  }
+}
+function evaluatePageAdvancedCondition(rule, ctx) {
+  const result = evaluatePageAdvancedConditionResult(rule, ctx);
+  if (!result.matched && result.reason?.startsWith("js_error")) {
+    try {
+      console.warn("[drip] Page trigger failed closed", {
+        pageId: rule.id,
+        pageName: rule.name,
+        error: result.error
+      });
+    } catch {
+    }
+  }
+  return result.matched;
+}
+function pageManualTriggerMatches(rule, ctx) {
+  const mode = rule.trigger?.mode;
+  if (mode !== "manual-callback" && mode !== "manual-api") return true;
+  const signal = rule.trigger?.signal;
+  if (!signal) return false;
+  return ctx.attributes[signal] === true;
+}
+function matchPageTargetingRule(rule, ctx) {
+  if (rule.disabled || rule.trigger?.disabled) return false;
+  const includeRules = rule.includeRules ?? [];
+  const excludeRules = (rule.excludeRules ?? []).map((item) => ({ ...item, include: false }));
+  const urlMatched = matchUrlRules(ctx.url, [...includeRules, ...excludeRules]);
+  return urlMatched && pageManualTriggerMatches(rule, ctx) && evaluatePageAdvancedCondition(rule, ctx);
+}
+function matchPageRules(rules, ctx) {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+  for (const rule of rules) {
+    const matched = matchPageTargetingRule(rule, ctx);
+    if (rule.include === false) {
+      if (matched) return false;
+    } else {
+      hasInclude = true;
+      if (matched) included = true;
+    }
+  }
+  return included || !hasInclude;
+}
+function matchAttributeRule(attrs, rule) {
+  if (rule.attribute === FAIL_CLOSED_TARGETING_ATTRIBUTE) return false;
+  const value = attrs[rule.attribute];
+  switch (rule.operator) {
+    case "exists":
+      return value !== void 0 && value !== null;
+    case "equals":
+      return value === rule.value;
+    case "contains":
+      return typeof value === "string" && typeof rule.value === "string" ? value.includes(rule.value) : false;
+    case "in":
+      return Array.isArray(rule.value) ? rule.value.includes(String(value)) : false;
+    case "not_in":
+      return Array.isArray(rule.value) ? !rule.value.includes(String(value)) : false;
+    default:
+      return false;
+  }
+}
+var EMPTY_BROWSER_INFO = { name: "", version: "" };
+var EMPTY_OS_INFO = { name: "", version: "" };
+var highEntropyBrowserInfo = null;
+var highEntropyBrowserInfoRequested = false;
+function runtimeNavigator() {
+  return typeof navigator === "undefined" ? void 0 : navigator;
+}
+function lower(value) {
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+function normalizeVersion(value) {
+  if (typeof value !== "string") return "";
+  const match = value.match(/\d+(?:[._]\d+)*/);
+  return match ? match[0].replace(/_/g, ".") : "";
+}
+function firstVersionMatch(ua, patterns) {
+  for (const pattern of patterns) {
+    const match = ua.match(pattern);
+    const version = normalizeVersion(match?.[1]);
+    if (version) return version;
+  }
+  return "";
+}
+function getUserAgent() {
+  return runtimeNavigator()?.userAgent ?? "";
+}
+function getPlatform() {
+  const nav = runtimeNavigator();
+  return nav?.userAgentData?.platform || nav?.platform || "";
+}
+function getDeviceTypeFromUserAgent(ua, platform) {
+  const normalizedUa = ua.toLowerCase();
+  const normalizedPlatform = platform.toLowerCase();
+  if (!normalizedUa && !normalizedPlatform) return "";
+  const isIpad = /\bipad\b/.test(normalizedUa) || normalizedPlatform === "macintel" && typeof navigator !== "undefined" && Number(navigator.maxTouchPoints || 0) > 1;
+  if (isIpad || /\btablet\b|playbook|silk|kindle|nexus 7|nexus 9|sm-t|gt-p/i.test(ua)) {
+    return "tablet";
+  }
+  if (/\bmobi\b|iphone|ipod|android.*mobile|windows phone|blackberry|bb10/i.test(ua)) {
+    return "mobile";
+  }
+  if (/android/i.test(ua)) return "tablet";
+  if (/android/i.test(normalizedPlatform)) return "tablet";
+  if (/windows|macintosh|mac os x|linux|x11|cros/i.test(ua) || normalizedPlatform) {
+    return "desktop";
+  }
+  return "";
+}
+function getDeviceType() {
+  const nav = runtimeNavigator();
+  if (nav?.userAgentData?.mobile === true) return "mobile";
+  const fromUa = getDeviceTypeFromUserAgent(getUserAgent(), getPlatform());
+  if (fromUa) return fromUa;
+  if (typeof window === "undefined") return "";
+  const width = window.innerWidth || 0;
+  if (width > 0 && width < 768) return "mobile";
+  if (width >= 768 && width < 1024) return "tablet";
+  return "desktop";
+}
+var DEVICE_TYPE_TOKENS = /* @__PURE__ */ new Set(["desktop", "mobile", "tablet"]);
+function normalizeDeviceType(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  return DEVICE_TYPE_TOKENS.has(normalized) ? normalized : void 0;
+}
+function browserInfoFromBrands(brands) {
+  if (!Array.isArray(brands)) return EMPTY_BROWSER_INFO;
+  for (const item of brands) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    const brand = lower(record.brand);
+    const version = normalizeVersion(record.version);
+    if (!brand || brand.includes("not") || brand.includes("brand")) continue;
+    if (brand.includes("edge")) return { name: "edge", version };
+    if (brand.includes("chrome") || brand.includes("chromium")) return { name: "chrome", version };
+    if (brand.includes("firefox")) return { name: "firefox", version };
+    if (brand.includes("safari")) return { name: "safari", version };
+  }
+  return EMPTY_BROWSER_INFO;
+}
+function requestHighEntropyBrowserInfo() {
+  const userAgentData = runtimeNavigator()?.userAgentData;
+  if (!userAgentData?.getHighEntropyValues || highEntropyBrowserInfoRequested) return;
+  highEntropyBrowserInfoRequested = true;
+  try {
+    userAgentData.getHighEntropyValues(["brands", "fullVersionList"]).then((values) => {
+      if (!values || typeof values !== "object") return;
+      const record = values;
+      const info = browserInfoFromBrands(record.fullVersionList ?? record.brands);
+      if (info.name) highEntropyBrowserInfo = info;
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+function getBrowserInfoFromClientHints() {
+  const userAgentData = runtimeNavigator()?.userAgentData;
+  const fullVersionInfo = browserInfoFromBrands(userAgentData?.fullVersionList);
+  if (fullVersionInfo.name) return fullVersionInfo;
+  if (highEntropyBrowserInfo?.name) return highEntropyBrowserInfo;
+  requestHighEntropyBrowserInfo();
+  return browserInfoFromBrands(userAgentData?.brands);
+}
+function browserWithVersionPriority(name, uaVersion, hinted) {
+  return {
+    name,
+    version: hinted.name === name && hinted.version ? hinted.version : uaVersion || hinted.version
+  };
+}
+function getBrowserInfo() {
+  const hinted = getBrowserInfoFromClientHints();
+  const ua = getUserAgent();
+  if (!ua) return hinted;
+  if (/Edg\//.test(ua)) {
+    return browserWithVersionPriority("edge", firstVersionMatch(ua, [/Edg\/([\d.]+)/]), hinted);
+  }
+  if (/Firefox\//.test(ua)) {
+    return browserWithVersionPriority("firefox", firstVersionMatch(ua, [/Firefox\/([\d.]+)/]), hinted);
+  }
+  if (/CriOS\//.test(ua)) {
+    return browserWithVersionPriority("chrome", firstVersionMatch(ua, [/CriOS\/([\d.]+)/]), hinted);
+  }
+  if (/Chrome\//.test(ua) && !/Chromium|OPR\/|Edg\//.test(ua)) {
+    return browserWithVersionPriority("chrome", firstVersionMatch(ua, [/Chrome\/([\d.]+)/]), hinted);
+  }
+  if (/Version\/[\d.]+.*Safari\//.test(ua) && !/Chrome|CriOS|FxiOS|Edg\//.test(ua)) {
+    return browserWithVersionPriority("safari", firstVersionMatch(ua, [/Version\/([\d.]+)/]), hinted);
+  }
+  return hinted;
+}
+function getOsInfo() {
+  const ua = getUserAgent();
+  const platform = getPlatform();
+  const normalized = `${ua} ${platform}`.toLowerCase();
+  if (!normalized.trim()) return EMPTY_OS_INFO;
+  if (/iphone|ipad|ipod/.test(normalized) || platform === "MacIntel" && typeof navigator !== "undefined" && Number(navigator.maxTouchPoints || 0) > 1) {
+    return { name: "ios", version: firstVersionMatch(ua, [/OS ([\d_]+)/]) };
+  }
+  if (/android/.test(normalized)) {
+    return { name: "android", version: firstVersionMatch(ua, [/Android ([\d.]+)/]) };
+  }
+  if (/windows/.test(normalized)) {
+    return { name: "windows", version: firstVersionMatch(ua, [/Windows NT ([\d.]+)/]) };
+  }
+  if (/mac os x|macintosh|macintel/.test(normalized)) {
+    return { name: "macos", version: firstVersionMatch(ua, [/Mac OS X ([\d_]+)/]) };
+  }
+  if (/linux|x11/.test(normalized)) {
+    return { name: "linux", version: "" };
+  }
+  return EMPTY_OS_INFO;
+}
+function getLanguage() {
+  const navLanguage = runtimeNavigator()?.language;
+  if (typeof navLanguage === "string" && navLanguage.trim()) return navLanguage;
+  if (typeof document !== "undefined") return document.documentElement.lang || "";
+  return "";
+}
+function decodeCookieComponent(value) {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+function getCookieValue(name) {
+  if (typeof document === "undefined") return void 0;
+  const needle = name.trim();
+  if (!needle) return void 0;
+  const pairs = document.cookie ? document.cookie.split(";") : [];
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    const rawName = (index >= 0 ? pair.slice(0, index) : pair).trim();
+    if (decodeCookieComponent(rawName) !== needle) continue;
+    return decodeCookieComponent(index >= 0 ? pair.slice(index + 1) : "");
+  }
+  return void 0;
+}
+function parseNamedValue(value) {
+  const raw = String(value ?? "").trim();
+  const index = raw.indexOf("=");
+  if (index < 0) return { name: raw, expected: "" };
+  return {
+    name: raw.slice(0, index).trim(),
+    expected: raw.slice(index + 1)
+  };
+}
+function getPersistedUtmValue(key) {
+  try {
+    const params = new URLSearchParams(location.search);
+    const direct = params.get(key);
+    if (direct) return direct;
+  } catch {
+  }
+  try {
+    const stored = sessionStorage.getItem("drip_utm");
+    if (!stored) return "";
+    const parsed = JSON.parse(stored);
+    return typeof parsed[key] === "string" ? parsed[key] : "";
+  } catch {
+    return "";
+  }
+}
+function normalizeReferrer() {
+  if (typeof document === "undefined") return "";
+  const referrer = document.referrer;
+  if (!referrer) return "(direct)";
+  try {
+    const host = new URL(referrer).hostname;
+    return host === location.hostname ? "(internal)" : host;
+  } catch {
+    return "(direct)";
+  }
+}
+function normalizeTrafficSource(utmSource, referrer) {
+  const source = typeof utmSource === "string" ? utmSource.toLowerCase() : "";
+  const ref = typeof referrer === "string" ? referrer.toLowerCase() : "";
+  if (source.includes("facebook") || source.includes("instagram") || source.includes("meta") || source.includes("tiktok")) {
+    return "paid-social";
+  }
+  if (source.includes("google") || source.includes("bing") || ref.includes("google") || ref.includes("bing")) {
+    return "search";
+  }
+  if (source.includes("email") || source.includes("newsletter")) return "email";
+  if (source) return source;
+  if (ref && ref !== "(direct)" && ref !== "(internal)") return "referral";
+  return "direct";
+}
+function readShopifySignal(signal) {
+  if (typeof window === "undefined") return void 0;
+  const root = window.ShopifyAnalytics?.meta ?? window.Shopify?.analytics?.meta;
+  if (!root || typeof root !== "object") return void 0;
+  if (signal === "shopify.page_type") {
+    return root.page?.pageType ?? root.page?.page_type ?? root.pageType;
+  }
+  if (signal === "shopify.product_type") {
+    return root.product?.type ?? root.product?.product_type;
+  }
+  if (signal === "shopify.product_tag") {
+    return root.product?.tags;
+  }
+  if (signal === "shopify.customer_tag") {
+    return root.customer?.tags;
+  }
+  return void 0;
+}
+function buildTargetingAttributes(baseAttributes = {}, currentUrl, options = {}) {
+  const attrs = { ...baseAttributes };
+  const href = currentUrl || (typeof location !== "undefined" ? location.href : "");
+  const persistSignals = options.persistSignals !== false;
+  try {
+    const parsed = new URL(href, typeof location !== "undefined" ? location.origin : "https://_");
+    attrs["url.full"] ??= parsed.href;
+    attrs["url.path"] ??= parsed.pathname;
+    attrs["url.query"] ??= parsed.search;
+  } catch {
+  }
+  attrs["utm.source"] ??= baseAttributes.utm_source ?? getPersistedUtmValue("utm_source");
+  attrs["utm.medium"] ??= baseAttributes.utm_medium ?? getPersistedUtmValue("utm_medium");
+  attrs["utm.campaign"] ??= baseAttributes.utm_campaign ?? getPersistedUtmValue("utm_campaign");
+  attrs.referrer ??= normalizeReferrer();
+  const deviceTypeOverride = attrs["device.type"] ?? baseAttributes.device;
+  attrs["device.type"] = normalizeDeviceType(deviceTypeOverride) ?? normalizeDeviceType(getDeviceType()) ?? "";
+  const browser = getBrowserInfo();
+  attrs["device.browser"] ??= browser.name;
+  attrs["device.browser.version"] ??= browser.version;
+  const os = getOsInfo();
+  attrs["device.os"] ??= os.name;
+  attrs["device.os.version"] ??= os.version;
+  attrs["navigator.language"] ??= getLanguage();
+  attrs["traffic.source"] ??= normalizeTrafficSource(attrs["utm.source"], attrs.referrer);
+  for (const signal of [
+    "shopify.page_type",
+    "shopify.product_type",
+    "shopify.product_tag",
+    "shopify.customer_tag"
+  ]) {
+    attrs[signal] ??= readShopifySignal(signal);
+  }
+  if (persistSignals) {
+    const productMeta = readShopifyProductMeta();
+    if (productMeta) rememberProduct(productMeta);
+  }
+  for (const [signal, value] of Object.entries(getSignals({ markVisitorSeen: persistSignals }))) {
+    attrs[signal] ??= value;
+  }
+  return attrs;
+}
+function resolveUrlQueryValue(url, conditionValue) {
+  const { name } = parseNamedValue(conditionValue);
+  if (!name) return void 0;
+  try {
+    const parsed = new URL(url, typeof location !== "undefined" ? location.origin : "https://_");
+    return parsed.searchParams.get(name) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveNamedConditionActual(condition, ctx) {
+  if (condition.signal === "cookie.value") {
+    const { name } = parseNamedValue(condition.value);
+    return getCookieValue(name);
+  }
+  if (condition.signal === "url.query") {
+    if (isLegacyRawQueryCondition(condition)) {
+      return rawQueryString(ctx.url);
+    }
+    return resolveUrlQueryValue(ctx.url, condition.value);
+  }
+  return condition.js ? evaluateJsTrigger(condition, ctx) : resolveSignalValue(ctx.attributes, ctx.url, condition.signal);
+}
+function resolveNamedConditionExpected(condition) {
+  if (condition.signal !== "cookie.value" && condition.signal !== "url.query") return condition.value;
+  if (condition.operator === "is_set" || condition.operator === "is_empty") return condition.value;
+  if (condition.signal === "url.query" && isLegacyRawQueryCondition(condition)) {
+    return condition.value;
+  }
+  return parseNamedValue(condition.value).expected;
+}
+var LEGACY_RAW_QUERY_OPERATORS = /* @__PURE__ */ new Set(["contains", "not_contains", "starts_with", "ends_with"]);
+function isLegacyRawQueryCondition(condition) {
+  if (!LEGACY_RAW_QUERY_OPERATORS.has(String(condition.operator))) return false;
+  return !String(condition.value ?? "").includes("=");
+}
+function rawQueryString(url) {
+  try {
+    const parsed = new URL(url, typeof location !== "undefined" ? location.origin : "https://_");
+    return parsed.search || "";
+  } catch {
+    return "";
+  }
+}
+function readShopifyProductMeta() {
+  if (typeof window === "undefined") return null;
+  const root = window.ShopifyAnalytics?.meta ?? window.Shopify?.analytics?.meta;
+  const product = root?.product;
+  if (!product || typeof product !== "object") return null;
+  const id = product.id ?? product.gid ?? product.product_id;
+  if (!id && !product.handle) return null;
+  return {
+    id,
+    handle: product.handle,
+    title: product.title,
+    type: product.type ?? product.product_type,
+    vendor: product.vendor,
+    tags: Array.isArray(product.tags) ? product.tags : void 0,
+    price: product.price
+  };
+}
+function resolveSignalValue(attrs, url, signal) {
+  if (attrs[signal] !== void 0) return attrs[signal];
+  try {
+    const parsed = new URL(url, "https://_");
+    if (signal === "url.full") return parsed.href;
+    if (signal === "url.path") return parsed.pathname;
+    if (signal === "url.query") return parsed.search;
+  } catch {
+  }
+  return void 0;
+}
+function buildJsTriggerSource(code) {
+  const trimmed = code.trim();
+  if (!trimmed) return "return false;";
+  if (/\breturn\b/.test(trimmed)) return trimmed;
+  return `return (${trimmed});`;
+}
+function isActivateJsTrigger(condition) {
+  const code = condition.js?.code ?? "";
+  return condition.js?.mode === "activate" || /\bactivate\s*\(/.test(code) || /\bcallbackFn\b/.test(code);
+}
+function evaluateJsTrigger(condition, ctx) {
+  return evaluateJsTriggerResult(condition, ctx).actual;
+}
+function evaluateJsTriggerResult(condition, ctx) {
+  const code = condition.js?.code?.trim();
+  if (!code || code.length > 4e3) return { actual: void 0 };
+  if (isActivateJsTrigger(condition)) {
+    return { actual: resolveSignalValue(ctx.attributes, ctx.url, condition.signal) };
+  }
+  try {
+    const url = new URL(
+      ctx.url,
+      typeof location !== "undefined" ? location.origin : "https://_"
+    );
+    const apexTools = createApexRuntimeTools();
+    const context = {
+      apexTools,
+      attributes: ctx.attributes,
+      document: typeof document !== "undefined" ? document : void 0,
+      location: typeof location !== "undefined" ? location : void 0,
+      signal: condition.signal,
+      url,
+      value: condition.value,
+      window: typeof window !== "undefined" ? window : void 0
+    };
+    const fn = new Function(
+      "context",
+      `"use strict";const attributes=context.attributes;const apexTools=context.apexTools;const document=context.document;const location=context.location;const signal=context.signal;const url=context.url;const value=context.value;const window=context.window;return Boolean((function(){${buildJsTriggerSource(code)}}).call(window));`
+    );
+    const actual = Boolean(fn(context));
+    return { actual, reason: actual ? void 0 : "js_false" };
+  } catch (error) {
+    return { actual: false, reason: jsErrorReason(error) };
+  }
+}
+function matchSegmentCondition(condition, ctx) {
+  const actual = resolveNamedConditionActual(condition, ctx);
+  const expected = resolveNamedConditionExpected(condition);
+  return matchSegmentConditionValues2(condition, actual, expected);
+}
+function matchSegmentConditionValues2(condition, actual, expected) {
+  return matchSegmentConditionValues(condition, actual, expected);
+}
+function matchSegmentRule(rule, ctx) {
+  const groups = Array.isArray(rule.rules?.groups) ? rule.rules.groups.filter((group) => Array.isArray(group) && group.length > 0) : [];
+  if (groups.length) {
+    return groups.every(
+      (group) => group.some((condition) => matchSegmentCondition(condition, ctx))
+    );
+  }
+  const conditions = rule.rules?.conditions ?? [];
+  if (!conditions.length) return true;
+  if (rule.rules.operator === "or") {
+    return conditions.some((condition) => matchSegmentCondition(condition, ctx));
+  }
+  return conditions.every((condition) => matchSegmentCondition(condition, ctx));
+}
+function matchSegmentRules(rules, ctx) {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+  for (const rule of rules) {
+    const matched = matchSegmentRule(rule, ctx);
+    if (rule.include === false) {
+      if (matched) return false;
+    } else {
+      hasInclude = true;
+      if (matched) included = true;
+    }
+  }
+  return included || !hasInclude;
+}
+function matchesTargeting(targeting, ctx) {
+  return evaluateTargetingGates(targeting, ctx).matched;
+}
+function evaluateTargetingGates(targeting, ctx) {
+  const gates = [];
+  if (!targeting) {
+    return {
+      matched: true,
+      gates: [
+        { id: "page", label: "Page check", status: "skipped", reason: "no_page_rules" },
+        { id: "audience", label: "Audience check", status: "skipped", reason: "no_audience_rules" }
+      ]
+    };
+  }
+  const urlRules = normalizeRuntimeUrlRules(targeting);
+  const pageRules = targeting.pageRules ?? [];
+  const pageHasRules = urlRules.length > 0 || pageRules.length > 0;
+  const pageMatched = pageHasRules ? matchUrlRules(
+    ctx.url,
+    urlRules,
+    ctx.hostAgnosticIncludeOrigin
+  ) && matchPageRules(pageRules, ctx) : true;
+  gates.push({
+    id: "page",
+    label: "Page check",
+    status: pageHasRules ? pageMatched ? "passed" : "failed" : "skipped",
+    reason: pageHasRules ? pageMatched ? "url_matched" : "url_mismatch" : "no_page_rules",
+    detail: pageHasRules ? { url: ctx.url, rules: urlRules.length, pageRules: pageRules.length } : void 0
+  });
+  if (!pageMatched) {
+    gates.push({
+      id: "audience",
+      label: "Audience check",
+      status: "skipped",
+      reason: "page_mismatch",
+      detail: { skipped: true }
+    });
+    return { matched: false, gates };
+  }
+  let attributesMatched = true;
+  const attributeRules = targeting.attributes ?? [];
+  for (const rule of attributeRules) {
+    if (!matchAttributeRule(ctx.attributes, rule)) {
+      attributesMatched = false;
+      break;
+    }
+  }
+  const segmentRules = targeting.segmentRules ?? [];
+  const segmentRefs = targeting.segments ?? [];
+  const segmentsExpanded = segmentRefs.every(
+    (ref) => segmentRules.some((rule) => rule.id === ref.id)
+  );
+  const segmentRulesMatched = segmentsExpanded && matchSegmentRules(segmentRules, ctx);
+  const audienceHasRules = attributeRules.length > 0 || segmentRules.length > 0 || segmentRefs.length > 0;
+  const audienceMatched = attributesMatched && segmentRulesMatched;
+  gates.push({
+    id: "audience",
+    label: "Audience check",
+    status: audienceHasRules ? audienceMatched ? "passed" : "failed" : "skipped",
+    reason: audienceHasRules ? audienceMatched ? "audience_matched" : !segmentsExpanded ? "segments_unexpanded" : !attributesMatched ? "attribute_mismatch" : "segment_mismatch" : "no_audience_rules",
+    detail: audienceHasRules ? { attributeRules: attributeRules.length, segmentRules: segmentRules.length } : void 0
+  });
+  return {
+    matched: pageMatched && audienceMatched,
+    gates
+  };
+}
+
+// ../shared-runtime/src/weekday-schedule.ts
+var WEEKDAYS = [
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+];
+var warnedInvalidTimezones = /* @__PURE__ */ new Set();
+function normalizeWeekdaySchedule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (Object.keys(record).some(
+    (key) => key !== "excludedDays" && key !== "timezone"
+  )) {
+    return null;
+  }
+  if (!Array.isArray(record.excludedDays)) return null;
+  if (!record.excludedDays.every(
+    (day) => typeof day === "string" && WEEKDAYS.includes(day)
+  )) {
+    return null;
+  }
+  const excludedDays = Array.from(new Set(record.excludedDays));
+  if (excludedDays.length < 1 || excludedDays.length > 6) return null;
+  if (typeof record.timezone !== "string") return null;
+  const timezone = record.timezone.trim();
+  if (!timezone) return null;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+  } catch {
+    return null;
+  }
+  return { excludedDays, timezone };
+}
+function warningTimezone(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? String(value.timezone ?? "unknown") : "unknown";
+}
+function isWeekdayExcluded(schedule, now2) {
+  if (!schedule) return false;
+  try {
+    const weekday = new Intl.DateTimeFormat("en-US", {
+      weekday: "long",
+      timeZone: schedule.timezone
+    }).format(now2).toLowerCase();
+    return Array.isArray(schedule.excludedDays) && schedule.excludedDays.includes(weekday);
+  } catch {
+    return false;
+  }
+}
+function weekdayScheduleBlocksDelivery(schedule, now2, logPrefix) {
+  if (schedule == null) return false;
+  const normalized = normalizeWeekdaySchedule(schedule);
+  if (!normalized) {
+    const timezone = warningTimezone(schedule);
+    const warnKey = `${logPrefix}:${timezone}`;
+    if (!warnedInvalidTimezones.has(warnKey)) {
+      warnedInvalidTimezones.add(warnKey);
+      console.warn(
+        `${logPrefix} Invalid weekday schedule (timezone "${timezone}" or malformed shape); delivery will fail open.`
+      );
+    }
+    return false;
+  }
+  return isWeekdayExcluded(normalized, now2);
+}
+
+// src/weekday-schedule.ts
+function weekdayScheduleBlocksDelivery2(schedule, now2) {
+  return weekdayScheduleBlocksDelivery(schedule, now2, "[drip]");
+}
+
+// src/flags.ts
+function evaluateFlag(flagId, experiments, context) {
+  const assignment = evaluateFlagAssignment(flagId, experiments, context);
+  return assignment !== null && !assignment.isControl;
+}
+function evaluateFlagAssignment(flagId, experiments, context) {
+  const experiment = experiments.find((e) => e.id === flagId);
+  if (!experiment) return null;
+  const forcedVariationId = context?.forceMap?.[experiment.id];
+  const forcedIndex = forcedVariationId ? experiment.variations.findIndex(
+    (variation2) => variation2.id === forcedVariationId
+  ) : -1;
+  const forcedVariation = forcedIndex >= 0 ? experiment.variations[forcedIndex] : null;
+  if (!forcedVariation && weekdayScheduleBlocksDelivery2(experiment.weekdaySchedule, /* @__PURE__ */ new Date())) {
+    return null;
+  }
+  const url = context?.url ?? (typeof location !== "undefined" ? location.href : "");
+  const attributes = buildTargetingAttributes(context?.attributes ?? {}, url);
+  if (!matchesTargeting(experiment.targeting, { url, attributes })) {
+    return null;
+  }
+  const userId = getUserId(context?.userId);
+  const hashValue = hashToFloat(experiment.id, userId);
+  if (!forcedVariation && !inTrafficAllocation(hashValue, experiment.trafficAllocation ?? 1)) {
+    return null;
+  }
+  const allocation = experiment.trafficAllocation ?? 1;
+  const variationHashValue = allocation >= 1 ? hashValue : variationHashToFloat(experiment.id, userId);
+  const weights = experiment.variations.map((v) => v.weight);
+  const index = forcedVariation ? forcedIndex : chooseVariation(variationHashValue, weights);
+  if (index < 0 || index >= experiment.variations.length) return null;
+  const variation = forcedVariation ?? experiment.variations[index];
+  return {
+    experimentId: experiment.id,
+    experimentName: void 0,
+    variationId: variation.id,
+    pageActive: true,
+    index,
+    mutations: variation.mutations ?? [],
+    value: variation.value,
+    featureFlag: experiment.featureFlag,
+    kind: experiment.kind ?? (experiment.featureFlag ? "feature_flag" : "experiment"),
+    css: variation.css,
+    js: variation.js,
+    resetJs: variation.resetJs,
+    externalCssUrl: variation.externalCssUrl,
+    externalJsUrl: variation.externalJsUrl,
+    harnessSession: variation.harnessSession,
+    isControl: Boolean(variation.isControl),
+    hashValue: userId
+  };
+}
+function evaluateFlagValue(flagId, experiments, context, fallback) {
+  const assignment = evaluateFlagAssignment(flagId, experiments, context);
+  if (!assignment) return fallback;
+  return assignment.value === void 0 ? fallback : assignment.value;
+}
+function defineFlagExperiment(def) {
+  const rollout = Math.max(0, Math.min(100, def.rolloutPercent ?? 0)) / 100;
+  const flag = defineExperiment({
+    slug: def.slug,
+    name: def.name,
+    trafficAllocation: 1,
+    targeting: def.targeting,
+    variations: [
+      {
+        id: "control",
+        weight: 1 - rollout,
+        mutations: [],
+        isControl: true,
+        value: def.offValue ?? false
+      },
+      {
+        id: "enabled",
+        weight: rollout,
+        mutations: [],
+        value: def.onValue ?? true
+      }
+    ]
+  });
+  return {
+    ...flag,
+    variations: flag.variations.map((variation) => ({ ...variation })),
+    featureFlag: { key: def.slug }
+  };
+}
+//# sourceMappingURL=flags.cjs.map