@fabricorg/experiments-web 0.0.2

package/dist/index.js

@@ -0,0 +1,653 @@
+// src/hash.ts
+function murmur3(key) {
+  const data = new TextEncoder().encode(key);
+  const len = data.length;
+  const nblocks = len >>> 2;
+  let h1 = 0;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  for (let i = 0; i < nblocks; i++) {
+    const o = i * 4;
+    let k12 = data[o] & 255 | (data[o + 1] & 255) << 8 | (data[o + 2] & 255) << 16 | (data[o + 3] & 255) << 24;
+    k12 = mul(k12, c1);
+    k12 = rot(k12, 15);
+    k12 = mul(k12, c2);
+    h1 ^= k12;
+    h1 = rot(h1, 13);
+    h1 = mul(h1, 5) + 3864292196 >>> 0;
+  }
+  let k1 = 0;
+  const tail = len & 3;
+  const ts = nblocks * 4;
+  if (tail >= 3) k1 ^= (data[ts + 2] & 255) << 16;
+  if (tail >= 2) k1 ^= (data[ts + 1] & 255) << 8;
+  if (tail >= 1) {
+    k1 ^= data[ts] & 255;
+    k1 = mul(k1, c1);
+    k1 = rot(k1, 15);
+    k1 = mul(k1, c2);
+    h1 ^= k1;
+  }
+  h1 ^= len;
+  h1 ^= h1 >>> 16;
+  h1 = mul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = mul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function rot(x, r) {
+  return (x << r | x >>> 32 - r) >>> 0;
+}
+function mul(a, b) {
+  const aH = a >>> 16 & 65535;
+  const aL = a & 65535;
+  const bH = b >>> 16 & 65535;
+  const bL = b & 65535;
+  return aL * bL + (aH * bL + aL * bH << 16 >>> 0 | 0) >>> 0;
+}
+function bucket(experimentId, salt, subjectId) {
+  return murmur3(`${experimentId}:${salt}:${subjectId}`) % 1e4;
+}
+
+// src/dom-ops.ts
+var DEFAULT_WAIT_MS = 2e3;
+var POLL_INTERVAL_MS = 50;
+function waitFor(selector, timeoutMs) {
+  return new Promise((resolve) => {
+    if (typeof document === "undefined") return resolve(null);
+    const initial = document.querySelector(selector);
+    if (initial) return resolve(initial);
+    if (timeoutMs <= 0) return resolve(null);
+    const deadline = Date.now() + timeoutMs;
+    const tick = () => {
+      const el = document.querySelector(selector);
+      if (el) return resolve(el);
+      if (Date.now() >= deadline) return resolve(null);
+      setTimeout(tick, POLL_INTERVAL_MS);
+    };
+    setTimeout(tick, POLL_INTERVAL_MS);
+  });
+}
+function injectStyle(experimentId, css) {
+  if (typeof document === "undefined") return;
+  const style = document.createElement("style");
+  style.dataset.fxExperiment = experimentId;
+  style.dataset.fxOp = "injectCSS";
+  style.textContent = css;
+  document.head.appendChild(style);
+}
+async function applyOne(experimentId, op) {
+  var _a;
+  if (typeof document === "undefined") return false;
+  if (op.op === "injectCSS") {
+    injectStyle(experimentId, op.value);
+    return true;
+  }
+  const wait = "waitForMs" in op && typeof op.waitForMs === "number" ? op.waitForMs : DEFAULT_WAIT_MS;
+  const el = await waitFor(op.selector, wait);
+  if (!el) return false;
+  switch (op.op) {
+    case "replaceText":
+      el.textContent = op.value;
+      return true;
+    case "replaceHTML":
+      el.innerHTML = op.value;
+      return true;
+    case "setAttr":
+      el.setAttribute(op.name, op.value);
+      return true;
+    case "addClass":
+      el.classList.add(...op.value.split(/\s+/).filter(Boolean));
+      return true;
+    case "removeClass":
+      el.classList.remove(...op.value.split(/\s+/).filter(Boolean));
+      return true;
+    case "setStyle":
+      el.style.setProperty(op.name, op.value);
+      return true;
+    case "remove":
+      (_a = el.parentNode) == null ? void 0 : _a.removeChild(el);
+      return true;
+    case "injectHTML":
+      el.insertAdjacentHTML(op.position, op.value);
+      return true;
+  }
+}
+async function applyDomOps(experimentId, ops) {
+  for (const op of ops) {
+    try {
+      await applyOne(experimentId, op);
+    } catch (e) {
+    }
+  }
+}
+
+// src/preview.ts
+function parsePreviewParams(search) {
+  if (!search) return null;
+  const q = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+  const fxp = q.get("fxpreview");
+  const tok = q.get("fxtoken");
+  if (!fxp || !tok) return null;
+  const [expId, variantKey] = fxp.split(":");
+  if (!expId || !variantKey) return null;
+  return { expId, variantKey, token: tok };
+}
+function b64urlToBytes(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+  const b64 = (s + pad).replace(/-/g, "+").replace(/_/g, "/");
+  const bin = typeof atob === "function" ? atob(b64) : Buffer.from(b64, "base64").toString("binary");
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function bytesToString(bytes) {
+  return typeof TextDecoder !== "undefined" ? new TextDecoder().decode(bytes) : Buffer.from(bytes).toString("utf8");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let r = 0;
+  for (let i = 0; i < a.length; i++) r |= a[i] ^ b[i];
+  return r === 0;
+}
+async function verifyPreviewToken(token, secret, manifest, now = Date.now()) {
+  var _a, _b;
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  const [headerB64, payloadB64, sigB64] = parts;
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(bytesToString(b64urlToBytes(headerB64)));
+    payload = JSON.parse(bytesToString(b64urlToBytes(payloadB64)));
+  } catch (e) {
+    return null;
+  }
+  if (header.alg !== "HS256") return null;
+  const subtle = (_b = (_a = globalThis.crypto) == null ? void 0 : _a.subtle) != null ? _b : null;
+  if (!subtle) return null;
+  const enc = new TextEncoder();
+  const key = await subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signed = enc.encode(`${headerB64}.${payloadB64}`);
+  const expectedBuf = await subtle.sign("HMAC", key, signed);
+  const expected = new Uint8Array(expectedBuf);
+  const provided = b64urlToBytes(sigB64);
+  if (!constantTimeEqual(expected, provided)) return null;
+  if (typeof payload.exp !== "number" || payload.exp * 1e3 < now || typeof payload.experimentId !== "string" || typeof payload.variantKey !== "string" || typeof payload.tenantId !== "string") {
+    return null;
+  }
+  if (payload.tenantId !== manifest.tenantId) return null;
+  return payload;
+}
+
+// src/storage.ts
+var DEFAULT_PREFIX = "fx.";
+function escape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cookieStorage(options = {}) {
+  var _a, _b;
+  const prefix = (_a = options.cookiePrefix) != null ? _a : DEFAULT_PREFIX;
+  const maxAge = (_b = options.cookieMaxAgeSeconds) != null ? _b : 365 * 24 * 60 * 60;
+  return {
+    read(experimentId) {
+      var _a2;
+      const k = prefix + experimentId;
+      if (typeof document !== "undefined" && document.cookie) {
+        const m = document.cookie.match(new RegExp(`(?:^|; )${escape(k)}=([^;]*)`));
+        if (m) return decodeURIComponent(m[1]);
+      }
+      try {
+        const v = (_a2 = globalThis.localStorage) == null ? void 0 : _a2.getItem(k);
+        if (v != null) return v;
+      } catch (e) {
+      }
+      return null;
+    },
+    write(experimentId, variantKey) {
+      var _a2;
+      const k = prefix + experimentId;
+      try {
+        if (typeof document !== "undefined") {
+          document.cookie = `${k}=${encodeURIComponent(variantKey)};max-age=${maxAge};path=/;samesite=lax`;
+        }
+      } catch (e) {
+      }
+      try {
+        (_a2 = globalThis.localStorage) == null ? void 0 : _a2.setItem(k, variantKey);
+      } catch (e) {
+      }
+    }
+  };
+}
+function localStorageOnly(options = {}) {
+  var _a;
+  const prefix = (_a = options.cookiePrefix) != null ? _a : DEFAULT_PREFIX;
+  return {
+    read(experimentId) {
+      var _a2, _b;
+      try {
+        return (_b = (_a2 = globalThis.localStorage) == null ? void 0 : _a2.getItem(prefix + experimentId)) != null ? _b : null;
+      } catch (e) {
+        return null;
+      }
+    },
+    write(experimentId, variantKey) {
+      var _a2;
+      try {
+        (_a2 = globalThis.localStorage) == null ? void 0 : _a2.setItem(prefix + experimentId, variantKey);
+      } catch (e) {
+      }
+    }
+  };
+}
+function sessionStorageOnly(options = {}) {
+  var _a;
+  const prefix = (_a = options.cookiePrefix) != null ? _a : DEFAULT_PREFIX;
+  return {
+    read(experimentId) {
+      var _a2, _b;
+      try {
+        return (_b = (_a2 = globalThis.sessionStorage) == null ? void 0 : _a2.getItem(prefix + experimentId)) != null ? _b : null;
+      } catch (e) {
+        return null;
+      }
+    },
+    write(experimentId, variantKey) {
+      var _a2;
+      try {
+        (_a2 = globalThis.sessionStorage) == null ? void 0 : _a2.setItem(prefix + experimentId, variantKey);
+      } catch (e) {
+      }
+    }
+  };
+}
+function inMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    read: (experimentId) => {
+      var _a;
+      return (_a = map.get(experimentId)) != null ? _a : null;
+    },
+    write: (experimentId, variantKey) => {
+      map.set(experimentId, variantKey);
+    }
+  };
+}
+function defaultStorage(options = {}) {
+  return cookieStorage(options);
+}
+var ANON_DEFAULT_COOKIE = "_fx_sid";
+var ANON_DEFAULT_TTL_DAYS = 365;
+function readCookie(name) {
+  if (typeof document === "undefined" || !document.cookie) return null;
+  const m = document.cookie.match(new RegExp(`(?:^|; )${escape(name)}=([^;]*)`));
+  return m ? decodeURIComponent(m[1]) : null;
+}
+function randomId() {
+  const c = globalThis.crypto;
+  if (c == null ? void 0 : c.randomUUID) return c.randomUUID();
+  if (c == null ? void 0 : c.getRandomValues) {
+    const a = new Uint8Array(16);
+    c.getRandomValues(a);
+    return Array.from(a, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return Date.now().toString(36) + Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+function getOrCreateAnonymousId(options = {}) {
+  var _a, _b, _c;
+  const cookieName = (_a = options.cookieName) != null ? _a : ANON_DEFAULT_COOKIE;
+  const ttlDays = (_b = options.ttlDays) != null ? _b : ANON_DEFAULT_TTL_DAYS;
+  const existing = readCookie(cookieName);
+  if (existing) return existing;
+  const fromStorage = (() => {
+    var _a2, _b2;
+    try {
+      return (_b2 = (_a2 = globalThis.localStorage) == null ? void 0 : _a2.getItem(cookieName)) != null ? _b2 : null;
+    } catch (e) {
+      return null;
+    }
+  })();
+  const id = fromStorage != null ? fromStorage : randomId();
+  try {
+    if (typeof document !== "undefined") {
+      const maxAge = ttlDays * 24 * 60 * 60;
+      document.cookie = `${cookieName}=${encodeURIComponent(id)};max-age=${maxAge};path=/;samesite=lax`;
+    }
+  } catch (e) {
+  }
+  try {
+    (_c = globalThis.localStorage) == null ? void 0 : _c.setItem(cookieName, id);
+  } catch (e) {
+  }
+  return id;
+}
+
+// src/trigger.ts
+function awaitTrigger(trigger) {
+  var _a;
+  if (!trigger || trigger.kind === "auto") return Promise.resolve(true);
+  if (trigger.kind === "urlMatch") {
+    if (typeof location === "undefined") return Promise.resolve(false);
+    const href = location.href;
+    if (trigger.regex) {
+      try {
+        return Promise.resolve(new RegExp(trigger.pattern).test(href));
+      } catch (e) {
+        return Promise.resolve(false);
+      }
+    }
+    return Promise.resolve(href.includes(trigger.pattern));
+  }
+  if (trigger.kind === "waitForSelector") {
+    if (typeof document === "undefined") return Promise.resolve(false);
+    const timeoutMs = (_a = trigger.timeoutMs) != null ? _a : 2e3;
+    return new Promise((resolve) => {
+      const found = document.querySelector(trigger.selector);
+      if (found) return resolve(true);
+      if (timeoutMs <= 0) return resolve(false);
+      const deadline = Date.now() + timeoutMs;
+      const tick = () => {
+        if (document.querySelector(trigger.selector)) return resolve(true);
+        if (Date.now() >= deadline) return resolve(false);
+        setTimeout(tick, 50);
+      };
+      setTimeout(tick, 50);
+    });
+  }
+  if (typeof addEventListener === "undefined") return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const handler = () => {
+      removeEventListener(trigger.name, handler);
+      resolve(true);
+    };
+    addEventListener(trigger.name, handler);
+  });
+}
+
+// src/index.ts
+async function init(options) {
+  var _a;
+  const f = (_a = options.fetchImpl) != null ? _a : globalThis.fetch;
+  if (!f) throw new Error("init: no fetch available");
+  const res = await f(options.manifestUrl);
+  if (!res.ok) throw new Error(`init: manifest fetch ${res.status}`);
+  const manifest = await res.json();
+  return createClient(manifest, options);
+}
+function createClient(manifest, options) {
+  var _a, _b, _c;
+  const exposed = /* @__PURE__ */ new Set();
+  const pending = [];
+  const pendingExposure = /* @__PURE__ */ new Map();
+  const forcedPreviews = /* @__PURE__ */ new Map();
+  const sharedApplied = /* @__PURE__ */ new Set();
+  const isExcluded = (() => {
+    if (options.excluded === false) return false;
+    if (options.excluded === true) return true;
+    if (typeof options.excluded === "function") {
+      try {
+        return Boolean(options.excluded());
+      } catch (e) {
+        return true;
+      }
+    }
+    return typeof navigator !== "undefined" && navigator.cookieEnabled === false;
+  })();
+  const storage = (_a = options.storage) != null ? _a : options.cookiePrefix ? cookieStorage({ cookiePrefix: options.cookiePrefix }) : defaultStorage();
+  const stackLimit = (_b = options.maxErrorStackLength) != null ? _b : 1e3;
+  const decisionAdapter = options.decisionAdapter;
+  const search = (_c = options.locationSearch) != null ? _c : typeof location !== "undefined" ? location.search : void 0;
+  const previewParams = parsePreviewParams(search);
+  if (previewParams && options.previewSecret) {
+    void verifyPreviewToken(previewParams.token, options.previewSecret, manifest).then((claim) => {
+      if (claim && claim.experimentId === previewParams.expId && claim.variantKey === previewParams.variantKey) {
+        forcedPreviews.set(claim.experimentId, claim.variantKey);
+      }
+    });
+  }
+  if (options.beaconEndpoint && typeof addEventListener !== "undefined") {
+    const flush = () => {
+      if (pending.length === 0) return;
+      const body = JSON.stringify({ exposures: pending.splice(0, pending.length) });
+      try {
+        const sb = navigator.sendBeacon;
+        if (sb == null ? void 0 : sb.call(navigator, options.beaconEndpoint, body)) return;
+      } catch (e) {
+      }
+      try {
+        fetch(options.beaconEndpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body,
+          keepalive: true
+        }).catch(() => void 0);
+      } catch (e) {
+      }
+    };
+    addEventListener("pagehide", flush);
+    addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") flush();
+    });
+  }
+  function decide(experimentId) {
+    var _a2;
+    const exp = manifest.experiments.find((e) => e.id === experimentId);
+    if (!exp) return { exp: null, variant: null, variantKey: null, preview: false };
+    const forced = forcedPreviews.get(experimentId);
+    if (forced) {
+      const v = exp.variants.find((vv) => vv.key === forced);
+      if (v) return { exp, variant: v, variantKey: forced, preview: true };
+    }
+    if (exp.state !== "running") {
+      return { exp, variant: null, variantKey: null, preview: false };
+    }
+    if (exp.divertTo) {
+      const v = exp.variants.find((vv) => vv.key === exp.divertTo);
+      if (v) return { exp, variant: v, variantKey: v.key, preview: false };
+    }
+    const sticky = storage.read(experimentId);
+    if (sticky && exp.variants.some((v) => v.key === sticky)) {
+      return {
+        exp,
+        variant: exp.variants.find((v) => v.key === sticky),
+        variantKey: sticky,
+        preview: false
+      };
+    }
+    if (exp.sampleRate < 1) {
+      const sb = bucket(`${exp.id}:sample`, exp.salt, options.subjectId) / 1e4;
+      if (sb >= exp.sampleRate)
+        return { exp, variant: null, variantKey: null, preview: false };
+    }
+    let chosenKey = null;
+    if (decisionAdapter) {
+      try {
+        const forced2 = decisionAdapter({
+          experimentId: exp.id,
+          salt: exp.salt,
+          subjectId: options.subjectId,
+          variants: exp.variants.map((v) => ({ key: v.key, weight: v.weight }))
+        });
+        if (forced2 && exp.variants.some((v) => v.key === forced2)) {
+          chosenKey = forced2;
+        }
+      } catch (e) {
+      }
+    }
+    const b = bucket(exp.id, exp.salt, options.subjectId);
+    let key;
+    if (chosenKey !== null) {
+      key = chosenKey;
+    } else {
+      const total = exp.variants.reduce((s, v) => {
+        var _a3;
+        return s + ((_a3 = v.weight) != null ? _a3 : 0);
+      }, 0);
+      if (total > 0) {
+        let cum = 0;
+        key = exp.variants[exp.variants.length - 1].key;
+        for (const v of exp.variants) {
+          cum += (_a2 = v.weight) != null ? _a2 : 0;
+          if (b < cum) {
+            key = v.key;
+            break;
+          }
+        }
+      } else {
+        const idx = Math.min(Math.floor(b / 1e4 * exp.variants.length), exp.variants.length - 1);
+        key = exp.variants[idx].key;
+      }
+    }
+    const chosen = exp.variants.find((v) => v.key === key);
+    if (typeof chosen.recipeSampleRate === "number" && chosen.recipeSampleRate < 1) {
+      const rs = bucket(`${exp.id}:${key}:rs`, exp.salt, options.subjectId) / 1e4;
+      if (rs >= chosen.recipeSampleRate) {
+        return { exp, variant: null, variantKey: null, preview: false };
+      }
+    }
+    return { exp, variant: chosen, variantKey: key, preview: false };
+  }
+  function truncStack(stack) {
+    if (!stack || stackLimit <= 0) return stack;
+    return stack.length > stackLimit ? stack.slice(0, stackLimit) : stack;
+  }
+  function expose(experimentId, variantKey, failure, preview) {
+    var _a2, _b2;
+    const sig = `${experimentId}:${variantKey}:${failure ? "F" : "O"}`;
+    if (exposed.has(sig)) return;
+    exposed.add(sig);
+    if (preview) return;
+    const record = {
+      experimentId,
+      subjectId: options.subjectId,
+      variantKey,
+      manifestVersion: manifest.manifestVersion,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      failure: failure ? { message: failure.message, stack: truncStack(failure.stack) } : null
+    };
+    (_a2 = options.onExposure) == null ? void 0 : _a2.call(options, record);
+    if (failure) (_b2 = options.onRecipeFailure) == null ? void 0 : _b2.call(options, record);
+    if (options.beaconEndpoint) pending.push(record);
+  }
+  function applyShared(exp) {
+    if (typeof document === "undefined") return;
+    if (sharedApplied.has(exp.id)) return;
+    sharedApplied.add(exp.id);
+    if (exp.sharedCss) {
+      const style = document.createElement("style");
+      style.dataset.fxExperiment = exp.id;
+      style.dataset.fxScope = "shared";
+      style.textContent = exp.sharedCss;
+      document.head.appendChild(style);
+    }
+    if (exp.sharedJs) {
+      try {
+        new Function("experiment", exp.sharedJs)(exp);
+      } catch (err) {
+        const e = err;
+        expose(exp.id, "shared", { message: e.message, stack: e.stack }, false);
+      }
+    }
+  }
+  function applyVariant(exp, variant) {
+    if (typeof document === "undefined") return true;
+    applyShared(exp);
+    if (variant.css) {
+      const style = document.createElement("style");
+      style.dataset.fxExperiment = exp.id;
+      style.textContent = variant.css;
+      document.head.appendChild(style);
+    }
+    if (variant.domOps && variant.domOps.length > 0) {
+      void applyDomOps(exp.id, variant.domOps);
+    }
+    if (variant.js) {
+      try {
+        new Function("experiment", "variant", variant.js)(exp, variant);
+      } catch (err) {
+        const e = err;
+        expose(exp.id, variant.key, { message: e.message, stack: e.stack }, false);
+        return false;
+      }
+    }
+    return true;
+  }
+  function activate(experimentId) {
+    var _a2;
+    if (isExcluded) return null;
+    const { exp, variant, variantKey, preview } = decide(experimentId);
+    if (!exp || !variant || !variantKey) return null;
+    if (!preview) storage.write(experimentId, variantKey);
+    const hostTrigger = (_a2 = options.triggers) == null ? void 0 : _a2[experimentId];
+    const manifestTrigger = exp.trigger;
+    const needsAsyncTrigger = !!hostTrigger || manifestTrigger !== void 0 && manifestTrigger.kind !== "auto";
+    const finish = () => {
+      const ok = exp.applyVariants ? applyVariant(exp, variant) : true;
+      if (!ok) return;
+      if (exp.manualExposure) {
+        pendingExposure.set(experimentId, { variant, preview });
+      } else {
+        expose(experimentId, variantKey, null, preview);
+      }
+    };
+    if (!needsAsyncTrigger) {
+      finish();
+    } else {
+      void (async () => {
+        if (hostTrigger) {
+          try {
+            const r = await hostTrigger();
+            if (r === false) return;
+          } catch (e) {
+            return;
+          }
+        }
+        if (manifestTrigger) {
+          const ok = await awaitTrigger(manifestTrigger);
+          if (!ok) return;
+        }
+        finish();
+      })();
+    }
+    return { variant, key: variantKey, preview };
+  }
+  return {
+    treatment(experimentId) {
+      const a = activate(experimentId);
+      return a ? a.key : null;
+    },
+    payload(experimentId) {
+      if (isExcluded) return void 0;
+      const { variant } = decide(experimentId);
+      return variant == null ? void 0 : variant.payload;
+    },
+    metadata(experimentId) {
+      const exp = manifest.experiments.find((e) => e.id === experimentId);
+      return exp == null ? void 0 : exp.metadata;
+    },
+    expose(experimentId) {
+      if (isExcluded) return;
+      const p = pendingExposure.get(experimentId);
+      if (!p) return;
+      pendingExposure.delete(experimentId);
+      expose(experimentId, p.variant.key, null, p.preview);
+    },
+    track(eventName, props) {
+      var _a2;
+      if (isExcluded) return;
+      (_a2 = options.onTrack) == null ? void 0 : _a2.call(options, eventName, props);
+    }
+  };
+}
+
+export { bucket as _bucket, murmur3 as _murmur3, applyDomOps, awaitTrigger, cookieStorage, createClient, defaultStorage, getOrCreateAnonymousId, inMemoryStorage, init, localStorageOnly, parsePreviewParams, sessionStorageOnly, verifyPreviewToken };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map