@pl4yzonellc/empire-analytics 0.0.2

package/dist/chunk-J5GXHJNU.js

@@ -0,0 +1,1105 @@
+// src/core/errors.ts
+var AnalyticsError = class extends Error {
+  code;
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "AnalyticsError";
+    this.code = options.code ?? "unknown";
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AnalyticsConfigError = class extends AnalyticsError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "config_invalid" });
+    this.name = "AnalyticsConfigError";
+  }
+};
+function toAnalyticsError(value, code) {
+  if (value instanceof AnalyticsError) {
+    return value;
+  }
+  const message = value instanceof Error && value.message ? value.message : `Analytics operation failed (${code})`;
+  return new AnalyticsError(message, { code, cause: value });
+}
+
+// src/core/environment.ts
+var ANALYTICS_ENVIRONMENTS = [
+  "development",
+  "test",
+  "staging",
+  "production"
+];
+function isAnalyticsEnvironment(value) {
+  return typeof value === "string" && ANALYTICS_ENVIRONMENTS.includes(value);
+}
+function defaultEnabledForEnvironment(environment) {
+  return environment === "production";
+}
+function defaultDebugForEnvironment(environment) {
+  return environment === "development";
+}
+
+// src/privacy/errors.ts
+var AnalyticsPrivacyError = class extends AnalyticsError {
+  key;
+  category;
+  constructor(params) {
+    super(`Analytics blocked a ${params.category} property: "${params.key}"`, {
+      code: "privacy_violation"
+    });
+    this.name = "AnalyticsPrivacyError";
+    this.key = params.key;
+    this.category = params.category;
+  }
+};
+
+// src/privacy/rules.ts
+var SENSITIVE_SUBSTRINGS = [
+  "password",
+  "passphrase",
+  "passcode",
+  "pwd",
+  "secret",
+  "token",
+  "apikey",
+  "accesskey",
+  "privatekey",
+  "secretkey",
+  "clientsecret",
+  "authorization",
+  "bearer",
+  "credential",
+  "jwt",
+  "creditcard",
+  "cardnumber",
+  "cardno",
+  "cvv",
+  "cvc",
+  "cardsecuritycode",
+  "ssn",
+  "socialsecurity",
+  "sortcode",
+  "routingnumber",
+  "accountnumber",
+  "iban",
+  "bankaccount"
+];
+var SENSITIVE_EXACT = /* @__PURE__ */ new Set([
+  "pin",
+  "otp",
+  "mfa",
+  "totp",
+  "auth",
+  "cookie",
+  "session",
+  "sessionid",
+  "salt",
+  "signature",
+  "sig",
+  "taxid",
+  "ein",
+  "nationalid",
+  "passportnumber",
+  "driverslicense",
+  "licensenumber",
+  "ccv",
+  "securitycode"
+]);
+var PII_SUBSTRINGS = [
+  "email",
+  "phone",
+  "firstname",
+  "lastname",
+  "fullname",
+  "givenname",
+  "familyname",
+  "streetaddress",
+  "homeaddress",
+  "mailingaddress",
+  "billingaddress",
+  "shippingaddress"
+];
+var PII_EXACT = /* @__PURE__ */ new Set([
+  "phonenumber",
+  "mobilenumber",
+  "mobilephone",
+  "telephone",
+  "tel",
+  "address",
+  "dob",
+  "dateofbirth",
+  "birthdate",
+  "ipaddress"
+]);
+var DEFAULT_SENSITIVE_KEYS = [
+  ...SENSITIVE_SUBSTRINGS,
+  ...SENSITIVE_EXACT
+];
+var DEFAULT_PII_KEYS = [...PII_SUBSTRINGS, ...PII_EXACT];
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function classifyKey(rawKey, options = {}) {
+  const normalized = normalizeKey(rawKey);
+  if (normalized === "") {
+    return null;
+  }
+  const allow = new Set((options.allowKeys ?? []).map(normalizeKey));
+  if (allow.has(normalized)) {
+    return null;
+  }
+  const extraBlocked = (options.extraBlockedKeys ?? []).map(normalizeKey);
+  if (extraBlocked.some((term) => term !== "" && normalized.includes(term))) {
+    return "sensitive";
+  }
+  if (SENSITIVE_EXACT.has(normalized)) {
+    return "sensitive";
+  }
+  if (SENSITIVE_SUBSTRINGS.some((term) => normalized.includes(term))) {
+    return "sensitive";
+  }
+  if (PII_EXACT.has(normalized)) {
+    return "pii";
+  }
+  if (PII_SUBSTRINGS.some((term) => normalized.includes(term))) {
+    return "pii";
+  }
+  return null;
+}
+
+// src/utils/logger.ts
+var NOOP = () => void 0;
+var SILENT_LOGGER = {
+  debug: NOOP,
+  info: NOOP,
+  warn: NOOP,
+  error: NOOP,
+  child: () => SILENT_LOGGER
+};
+function createLogger(options = {}) {
+  const { debug = false, prefix = "[Analytics]", sink } = options;
+  if (!debug) {
+    return SILENT_LOGGER;
+  }
+  const target = sink ?? (typeof console !== "undefined" ? console : { debug: NOOP, info: NOOP, warn: NOOP, error: NOOP });
+  const write = (level) => (message, data) => {
+    const line = `${prefix} ${message}`;
+    if (data === void 0) {
+      target[level](line);
+    } else {
+      target[level](line, data);
+    }
+  };
+  const logger = {
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error"),
+    child: (scope) => createLogger({ debug, prefix: `${prefix} ${scope}`, sink })
+  };
+  return logger;
+}
+
+// src/privacy/sanitize.ts
+var DEFAULT_POLICY = {
+  onSensitive: "strip",
+  onPii: "warn",
+  blockKeys: [],
+  allowKeys: [],
+  maxDepth: 4,
+  maxProperties: 64,
+  maxStringLength: 1024,
+  maxArrayLength: 64
+};
+var DROP = { keep: false };
+function sanitizeProperties(input, policy = DEFAULT_POLICY, logger = SILENT_LOGGER) {
+  const blocked = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  let kept = 0;
+  const handleViolation = (path, category) => {
+    blocked.push(path);
+    const mode = category === "sensitive" ? policy.onSensitive : policy.onPii;
+    if (mode === "throw") {
+      throw new AnalyticsPrivacyError({ key: path, category });
+    }
+    if (mode === "warn") {
+      logger.warn(`Blocked ${category} property "${path}" (value omitted)`);
+    }
+  };
+  const walkValue = (value2, depth, path) => {
+    if (value2 === null || value2 === void 0) return DROP;
+    switch (typeof value2) {
+      case "function":
+      case "symbol":
+        logger.debug(`Dropped ${typeof value2} value at "${path}"`);
+        return DROP;
+      case "bigint":
+        return { keep: true, value: value2.toString() };
+      case "boolean":
+        return { keep: true, value: value2 };
+      case "number":
+        return Number.isFinite(value2) ? { keep: true, value: value2 } : DROP;
+      case "string":
+        return {
+          keep: true,
+          value: value2.length > policy.maxStringLength ? value2.slice(0, policy.maxStringLength) : value2
+        };
+    }
+    if (value2 instanceof Date) {
+      return Number.isFinite(value2.getTime()) ? { keep: true, value: value2.toISOString() } : DROP;
+    }
+    if (typeof value2 !== "object" || value2 === null) return DROP;
+    if (seen.has(value2)) {
+      logger.debug(`Dropped circular reference at "${path}"`);
+      return DROP;
+    }
+    if (depth >= policy.maxDepth) {
+      logger.debug(`Dropped value at "${path}" (max depth ${policy.maxDepth})`);
+      return DROP;
+    }
+    seen.add(value2);
+    let outcome;
+    if (Array.isArray(value2)) {
+      const out = [];
+      for (const item of value2.slice(0, policy.maxArrayLength)) {
+        const child = walkValue(item, depth + 1, `${path}[]`);
+        if (child.keep) out.push(child.value);
+      }
+      outcome = { keep: true, value: out };
+    } else {
+      outcome = {
+        keep: true,
+        value: walkObject(value2, depth, path)
+      };
+    }
+    seen.delete(value2);
+    return outcome;
+  };
+  const walkObject = (obj, depth, parentPath) => {
+    const out = {};
+    for (const [key, raw] of Object.entries(obj)) {
+      const path = parentPath ? `${parentPath}.${key}` : key;
+      const classification = classifyKey(key, {
+        extraBlockedKeys: policy.blockKeys,
+        allowKeys: policy.allowKeys
+      });
+      if (classification === "sensitive") {
+        handleViolation(path, "sensitive");
+        continue;
+      }
+      if (classification === "pii") {
+        if (policy.onPii === "allow") ; else {
+          handleViolation(path, "pii");
+          continue;
+        }
+      }
+      if (kept >= policy.maxProperties) {
+        logger.debug(`Reached max property count (${policy.maxProperties}); dropping "${path}"`);
+        continue;
+      }
+      const child = walkValue(raw, depth + 1, path);
+      if (child.keep) {
+        out[key] = child.value;
+        kept += 1;
+      }
+    }
+    return out;
+  };
+  const root = input ?? {};
+  seen.add(root);
+  const value = walkObject(root, 0, "");
+  return { value, blocked };
+}
+
+// src/privacy/path.ts
+function stripSensitiveQueryParams(pathOrUrl) {
+  const queryIndex = pathOrUrl.indexOf("?");
+  if (queryIndex === -1) {
+    return pathOrUrl;
+  }
+  const base = pathOrUrl.slice(0, queryIndex);
+  const afterQuery = pathOrUrl.slice(queryIndex + 1);
+  const hashIndex = afterQuery.indexOf("#");
+  const rawQuery = hashIndex === -1 ? afterQuery : afterQuery.slice(0, hashIndex);
+  const hash = hashIndex === -1 ? "" : afterQuery.slice(hashIndex);
+  if (rawQuery === "") {
+    return pathOrUrl;
+  }
+  const kept = [];
+  for (const pair of rawQuery.split("&")) {
+    if (pair === "") continue;
+    const eq = pair.indexOf("=");
+    const key = decodeURIComponentSafe(eq === -1 ? pair : pair.slice(0, eq));
+    if (classifyKey(key) === "sensitive") {
+      continue;
+    }
+    kept.push(pair);
+  }
+  const query = kept.length > 0 ? `?${kept.join("&")}` : "";
+  return `${base}${query}${hash}`;
+}
+function decodeURIComponentSafe(value) {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+
+// src/utils/stable-stringify.ts
+function stableStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (input) => {
+    if (input === null) return "null";
+    if (input === void 0) return "undefined";
+    if (typeof input === "function") return '"[fn]"';
+    if (typeof input === "symbol") return '"[symbol]"';
+    if (typeof input === "string") return JSON.stringify(input);
+    if (typeof input === "boolean") return input ? "true" : "false";
+    if (typeof input === "bigint") return `"${input.toString()}n"`;
+    if (typeof input === "number") return Number.isFinite(input) ? `${input}` : '"[number]"';
+    if (typeof input === "object") {
+      if (seen.has(input)) return '"[circular]"';
+      seen.add(input);
+      let result;
+      if (Array.isArray(input)) {
+        result = `[${input.map((item) => walk(item)).join(",")}]`;
+      } else {
+        const record = input;
+        const keys = Object.keys(record).sort();
+        result = `{${keys.map((key) => `${JSON.stringify(key)}:${walk(record[key])}`).join(",")}}`;
+      }
+      seen.delete(input);
+      return result;
+    }
+    return '"[unknown]"';
+  };
+  return walk(value);
+}
+
+// src/core/config.ts
+function resolvePrivacy(privacy, environment, debug) {
+  const isProduction = environment === "production";
+  const defaultSensitive = debug ? "throw" : isProduction ? "strip" : "warn";
+  let onSensitive = privacy?.onSensitive ?? defaultSensitive;
+  let onPii = privacy?.onPii ?? "warn";
+  if (isProduction && onSensitive === "throw") onSensitive = "strip";
+  if (isProduction && onPii === "throw") onPii = "warn";
+  const clampPositive = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+  return {
+    onSensitive,
+    onPii,
+    blockKeys: privacy?.blockKeys ?? [],
+    allowKeys: privacy?.allowKeys ?? [],
+    maxDepth: clampPositive(privacy?.maxDepth, 4),
+    maxProperties: clampPositive(privacy?.maxProperties, 64),
+    maxStringLength: clampPositive(privacy?.maxStringLength, 1024),
+    maxArrayLength: clampPositive(privacy?.maxArrayLength, 64)
+  };
+}
+function resolvePlausible(config) {
+  const p = config.plausible;
+  if (!p || typeof p.domain !== "string" || p.domain.trim() === "") {
+    throw new AnalyticsConfigError(
+      "Plausible provider requires a non-empty `plausible.domain` (e.g. 'example.com')."
+    );
+  }
+  const resolved = {
+    domain: p.domain.trim(),
+    mode: p.mode === "package" ? "package" : "cdn",
+    injectScript: p.injectScript ?? true,
+    autoPageViews: p.autoPageViews ?? true,
+    hashRouting: p.hashRouting ?? false,
+    outboundLinks: p.outboundLinks ?? false,
+    fileDownloads: p.fileDownloads ?? false,
+    taggedEvents: p.taggedEvents ?? false,
+    revenue: p.revenue ?? true,
+    trackLocalhost: p.trackLocalhost ?? false
+  };
+  if (p.scriptUrl) resolved.scriptUrl = p.scriptUrl;
+  if (p.endpoint) resolved.endpoint = p.endpoint;
+  return { resolved };
+}
+function resolveConsole(config) {
+  const c = config.console;
+  const fallbackSink = typeof console !== "undefined" ? console : {
+    log: () => void 0,
+    info: () => void 0,
+    group: () => void 0,
+    groupEnd: () => void 0
+  };
+  return {
+    sink: c?.sink ?? fallbackSink,
+    prefix: c?.prefix ?? "[Analytics:console]"
+  };
+}
+function resolveConfig(config) {
+  if (config == null || typeof config !== "object") {
+    throw new AnalyticsConfigError("Analytics config must be an object.");
+  }
+  if (!isAnalyticsEnvironment(config.environment)) {
+    throw new AnalyticsConfigError(
+      `Unknown environment "${String(
+        config.environment
+      )}". Expected: development | test | staging | production.`
+    );
+  }
+  const environment = config.environment;
+  const providerName = config.provider;
+  if (providerName !== "plausible" && providerName !== "console" && providerName !== "custom") {
+    throw new AnalyticsConfigError(
+      `Unknown provider "${providerName}". Expected: plausible | console | custom.`
+    );
+  }
+  const enabledExplicit = typeof config.enabled === "boolean";
+  const enabled = enabledExplicit ? config.enabled : defaultEnabledForEnvironment(environment);
+  const disabledReason = enabled ? void 0 : enabledExplicit ? "analytics disabled by config (enabled: false)" : `analytics disabled by default for the "${environment}" environment`;
+  const debug = typeof config.debug === "boolean" ? config.debug : defaultDebugForEnvironment(environment);
+  const resolved = {
+    provider: config.provider,
+    environment,
+    enabled,
+    debug,
+    includeTenantKey: config.includeTenantKey ?? false,
+    tenantPropertyName: config.tenantPropertyName ?? "tenant",
+    defaultProperties: { ...config.defaultProperties },
+    privacy: resolvePrivacy(config.privacy, environment, debug)
+  };
+  if (disabledReason) resolved.disabledReason = disabledReason;
+  if (typeof config.tenantKey === "string" && config.tenantKey !== "") {
+    resolved.tenantKey = config.tenantKey;
+  }
+  if (config.onError) resolved.onError = config.onError;
+  if (config.onEvent) resolved.onEvent = config.onEvent;
+  if (config.provider === "plausible") {
+    resolved.plausible = resolvePlausible(config).resolved;
+  } else if (config.provider === "console") {
+    resolved.console = resolveConsole(config);
+  } else {
+    if (typeof config.adapter !== "function") {
+      throw new AnalyticsConfigError(
+        "Custom provider requires an `adapter` factory: { provider: 'custom', adapter: (ctx) => AnalyticsAdapter }."
+      );
+    }
+    resolved.adapter = config.adapter;
+  }
+  return resolved;
+}
+function configSignature(config) {
+  return stableStringify(config);
+}
+
+// src/utils/env.ts
+function getWindow() {
+  return typeof window !== "undefined" ? window : void 0;
+}
+function getDocument() {
+  return typeof document !== "undefined" ? document : void 0;
+}
+
+// src/providers/plausible/script.ts
+var SCRIPT_MARKER = "data-empire-analytics";
+var SCRIPT_MARKER_VALUE = "plausible";
+var DEFAULT_HOST = "https://plausible.io";
+var EXTENSION_ORDER = [
+  "hash",
+  "outbound-links",
+  "file-downloads",
+  "tagged-events",
+  "pageview-props",
+  "revenue",
+  "compat",
+  "manual",
+  "local"
+];
+var loadPromises = /* @__PURE__ */ new Map();
+var managedScripts = /* @__PURE__ */ new Set();
+var createdQueueStub = false;
+function buildScriptUrl(options) {
+  if (options.scriptUrl) {
+    return options.scriptUrl;
+  }
+  const requested = new Set(options.extensions ?? []);
+  const ordered = EXTENSION_ORDER.filter((ext) => requested.has(ext));
+  const suffix = ordered.length > 0 ? `.${ordered.join(".")}` : "";
+  return `${DEFAULT_HOST}/js/script${suffix}.js`;
+}
+function ensureQueueStub() {
+  const win = getWindow();
+  if (!win) return;
+  if (typeof win.plausible === "function") return;
+  const stub = function plausibleStub(...args) {
+    (stub.q = stub.q ?? []).push(args);
+  };
+  stub.q = [];
+  win.plausible = stub;
+  createdQueueStub = true;
+}
+function findExistingScript(doc, src) {
+  const ours = doc.querySelector(
+    `script[${SCRIPT_MARKER}="${SCRIPT_MARKER_VALUE}"]`
+  );
+  if (ours) return ours;
+  const scripts = Array.from(doc.querySelectorAll("script[src]"));
+  return scripts.find(
+    (el) => el.src === src || el.src.includes("/js/script") && el.hasAttribute("data-domain")
+  ) ?? null;
+}
+function loadPlausibleScript(options, logger = SILENT_LOGGER) {
+  const win = getWindow();
+  const doc = getDocument();
+  if (!win || !doc) {
+    logger.debug("No browser environment; skipping Plausible script load");
+    return Promise.resolve();
+  }
+  const src = buildScriptUrl(options);
+  ensureQueueStub();
+  const cached = loadPromises.get(src);
+  if (cached) return cached;
+  const existing = findExistingScript(doc, src);
+  if (existing) {
+    logger.debug("Plausible script already present; not injecting a duplicate");
+    const resolved = Promise.resolve();
+    loadPromises.set(src, resolved);
+    return resolved;
+  }
+  const promise = new Promise((resolve, reject) => {
+    const script = doc.createElement("script");
+    script.src = src;
+    script.defer = true;
+    script.setAttribute(SCRIPT_MARKER, SCRIPT_MARKER_VALUE);
+    script.setAttribute("data-domain", options.domain);
+    if (options.endpoint) {
+      script.setAttribute("data-api", options.endpoint);
+    }
+    script.addEventListener("load", () => {
+      logger.debug("Plausible script loaded", { src });
+      resolve();
+    });
+    script.addEventListener("error", () => {
+      managedScripts.delete(script);
+      script.remove();
+      loadPromises.delete(src);
+      logger.debug("Plausible script failed to load", { src });
+      reject(
+        new AnalyticsError("Analytics tracking script failed to load", {
+          code: "script_load_failed"
+        })
+      );
+    });
+    const mount = doc.head ?? doc.body ?? doc.documentElement;
+    mount.appendChild(script);
+    managedScripts.add(script);
+  });
+  loadPromises.set(src, promise);
+  return promise;
+}
+function removePlausibleScript() {
+  for (const script of managedScripts) {
+    script.remove();
+  }
+  managedScripts.clear();
+  loadPromises.clear();
+  if (createdQueueStub) {
+    const win = getWindow();
+    if (win) {
+      try {
+        delete win.plausible;
+      } catch {
+        win.plausible = void 0;
+      }
+    }
+    createdQueueStub = false;
+  }
+}
+
+// src/providers/plausible/revenue.ts
+function toPlausiblePayload(properties) {
+  if (!properties) return void 0;
+  const { revenue, currency, ...rest } = properties;
+  const amount = typeof revenue === "number" ? revenue : isRevenueObject(revenue) && typeof revenue.amount === "number" ? revenue.amount : void 0;
+  const currencyCode = typeof currency === "string" ? currency : isRevenueObject(revenue) && typeof revenue.currency === "string" ? revenue.currency : void 0;
+  const props = {};
+  for (const [key, value] of Object.entries(rest)) {
+    const coerced = coerce(value);
+    if (coerced !== void 0) {
+      props[key] = coerced;
+    }
+  }
+  const options = {};
+  if (amount !== void 0 && Number.isFinite(amount) && currencyCode) {
+    options.revenue = { amount, currency: currencyCode };
+  } else {
+    if (amount !== void 0 && Number.isFinite(amount)) props.revenue = amount;
+    if (currencyCode) props.currency = currencyCode;
+  }
+  if (Object.keys(props).length > 0) {
+    options.props = props;
+  }
+  return Object.keys(options).length > 0 ? options : void 0;
+}
+function isRevenueObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function coerce(value) {
+  if (value === null || value === void 0) return void 0;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") {
+    return value;
+  }
+  if (type === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+
+// src/providers/plausible/package-runtime.ts
+var SPECIFIER = "@plausible-analytics/tracker";
+var cache;
+function loadPlausibleTrackerModule(logger) {
+  cache ??= importTrackerModule(logger);
+  return cache;
+}
+async function importTrackerModule(logger) {
+  try {
+    const mod = await import(SPECIFIER);
+    if (typeof mod.init !== "function" || typeof mod.track !== "function") {
+      throw new Error(`"${SPECIFIER}" did not export init()/track()`);
+    }
+    return { init: mod.init, track: mod.track };
+  } catch (cause) {
+    cache = void 0;
+    logger.debug(`Could not load ${SPECIFIER}`, {
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+    throw new AnalyticsError(
+      `Plausible "package" mode needs the optional peer dependency "${SPECIFIER}". Run \`pnpm add ${SPECIFIER}\` or switch to \`plausible.mode: 'cdn'\`.`,
+      { code: "provider_unavailable", cause }
+    );
+  }
+}
+
+// src/providers/plausible/PlausibleAdapter.ts
+function resolveExtensions(config) {
+  const extensions = [];
+  if (!config.autoPageViews) extensions.push("manual");
+  if (config.hashRouting) extensions.push("hash");
+  if (config.outboundLinks) extensions.push("outbound-links");
+  if (config.fileDownloads) extensions.push("file-downloads");
+  if (config.taggedEvents) extensions.push("tagged-events");
+  if (config.revenue) extensions.push("revenue");
+  if (config.trackLocalhost) extensions.push("local");
+  return extensions;
+}
+function toAbsoluteUrl(path, win) {
+  try {
+    return new URL(path, win.location.href).toString();
+  } catch {
+    return path;
+  }
+}
+var PlausibleAdapter = class {
+  name = "plausible";
+  #config;
+  #logger;
+  #packageTrack = null;
+  constructor(config, context) {
+    this.#config = config;
+    this.#logger = context.logger.child("[plausible]");
+  }
+  async initialize() {
+    const win = getWindow();
+    if (!win) {
+      this.#logger.debug("No window; Plausible runs browser-side only (SSR no-op)");
+      return;
+    }
+    if (this.#config.mode === "package") {
+      await this.#initPackage();
+      return;
+    }
+    if (this.#config.injectScript) {
+      await loadPlausibleScript(
+        {
+          domain: this.#config.domain,
+          scriptUrl: this.#config.scriptUrl,
+          endpoint: this.#config.endpoint,
+          extensions: resolveExtensions(this.#config)
+        },
+        this.#logger
+      );
+    } else {
+      this.#logger.debug("injectScript=false; expecting a host-provided Plausible snippet");
+      ensureQueueStub();
+    }
+  }
+  track(eventName, properties) {
+    const payload = toPlausiblePayload(properties);
+    if (this.#config.mode === "package") {
+      this.#packageCall(eventName, payload);
+    } else {
+      this.#cdnCall(eventName, payload);
+    }
+  }
+  pageView(path) {
+    const win = getWindow();
+    const url = path && win ? toAbsoluteUrl(path, win) : void 0;
+    if (this.#config.mode === "package") {
+      this.#packageCall("pageview", url ? { u: url } : void 0);
+      return;
+    }
+    this.#cdnCall("pageview", url ? { u: url } : void 0);
+  }
+  destroy() {
+    if (this.#config.mode === "package") {
+      this.#packageTrack = null;
+      return;
+    }
+    if (this.#config.injectScript) {
+      removePlausibleScript();
+    }
+  }
+  async #initPackage() {
+    const mod = await loadPlausibleTrackerModule(this.#logger);
+    const initConfig = {
+      domain: this.#config.domain,
+      autoCapturePageviews: this.#config.autoPageViews,
+      hashBasedRouting: this.#config.hashRouting,
+      outboundLinks: this.#config.outboundLinks,
+      fileDownloads: this.#config.fileDownloads,
+      captureOnLocalhost: this.#config.trackLocalhost,
+      bindToWindow: false,
+      logging: false
+    };
+    if (this.#config.endpoint) initConfig.endpoint = this.#config.endpoint;
+    mod.init(initConfig);
+    this.#packageTrack = mod.track;
+    this.#logger.debug("Plausible tracker package ready", { domain: this.#config.domain });
+  }
+  #packageCall(eventName, cdnPayload) {
+    const track = this.#packageTrack;
+    if (!track) {
+      this.#logger.debug("Plausible tracker not ready; event dropped", { event: eventName });
+      return;
+    }
+    const options = {};
+    if (cdnPayload?.props) options.props = cdnPayload.props;
+    if (cdnPayload?.revenue) options.revenue = cdnPayload.revenue;
+    if (cdnPayload?.u) options.url = cdnPayload.u;
+    try {
+      if (Object.keys(options).length > 0) {
+        track(eventName, options);
+      } else {
+        track(eventName);
+      }
+    } catch (error) {
+      this.#logger.debug("Plausible tracker threw; event dropped", {
+        event: eventName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  #cdnCall(eventName, options) {
+    const win = getWindow();
+    const plausible = win?.plausible;
+    if (typeof plausible !== "function") {
+      this.#logger.debug("window.plausible unavailable; event dropped", { event: eventName });
+      return;
+    }
+    try {
+      if (options) {
+        plausible(eventName, options);
+      } else {
+        plausible(eventName);
+      }
+    } catch (error) {
+      this.#logger.debug("window.plausible threw; event dropped", {
+        event: eventName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+};
+
+// src/providers/console/ConsoleAdapter.ts
+var ConsoleAdapter = class {
+  name = "console";
+  #config;
+  constructor(config, _context) {
+    this.#config = config;
+  }
+  initialize() {
+    this.#config.sink.info(`${this.#config.prefix} ready`);
+  }
+  track(eventName, properties) {
+    this.#config.sink.log(`${this.#config.prefix} track`, {
+      event: eventName,
+      properties: properties ?? {}
+    });
+  }
+  pageView(path) {
+    this.#config.sink.log(`${this.#config.prefix} pageView`, { path: path ?? "(current)" });
+  }
+  destroy() {
+    this.#config.sink.info(`${this.#config.prefix} destroyed`);
+  }
+};
+
+// src/providers/factory.ts
+function createAdapter(config, context) {
+  switch (config.provider) {
+    case "plausible": {
+      if (!config.plausible) {
+        throw new AnalyticsConfigError("Resolved config is missing the Plausible block.");
+      }
+      return new PlausibleAdapter(config.plausible, context);
+    }
+    case "console": {
+      if (!config.console) {
+        throw new AnalyticsConfigError("Resolved config is missing the console block.");
+      }
+      return new ConsoleAdapter(config.console, context);
+    }
+    case "custom": {
+      if (!config.adapter) {
+        throw new AnalyticsConfigError("Resolved config is missing the custom adapter factory.");
+      }
+      return config.adapter(context);
+    }
+    default: {
+      const exhaustive = config.provider;
+      throw new AnalyticsConfigError(`Unsupported provider: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/core/AnalyticsClient.ts
+var AnalyticsClientImpl = class {
+  #config = null;
+  #adapter = null;
+  #logger = createLogger();
+  #initialized = false;
+  #enabled = false;
+  #signature = null;
+  #initPromise = null;
+  /** Bumped on every initialize()/destroy(); guards stale async work. */
+  #epoch = 0;
+  async initialize(config) {
+    const resolved = resolveConfig(config);
+    const signature = configSignature(config);
+    if (this.#initialized && this.#signature === signature) {
+      await (this.#initPromise ?? Promise.resolve());
+      return;
+    }
+    if (this.#initialized) {
+      this.#teardownAdapter();
+    }
+    this.#epoch += 1;
+    this.#config = resolved;
+    this.#signature = signature;
+    this.#logger = createLogger({ debug: resolved.debug });
+    this.#enabled = resolved.enabled;
+    this.#initialized = true;
+    if (!resolved.enabled) {
+      this.#logger.debug("Analytics disabled", {
+        environment: resolved.environment,
+        provider: resolved.provider,
+        reason: resolved.disabledReason
+      });
+      this.#initPromise = Promise.resolve();
+      return;
+    }
+    this.#initPromise = this.#startAdapter(resolved);
+    await this.#initPromise;
+  }
+  track(event, ...args) {
+    const properties = args[0];
+    try {
+      if (!this.#initialized || !this.#config) {
+        this.#logger.warn(`track("${event}") called before initialize()`);
+        return;
+      }
+      const config = this.#config;
+      const baseInfo = {
+        type: "event",
+        name: event,
+        provider: config.provider,
+        environment: config.environment,
+        enabled: this.#enabled
+      };
+      if (!this.#enabled) {
+        const reason = config.disabledReason ?? "analytics disabled";
+        this.#logger.debug("Event skipped", { ...baseInfo, reason });
+        this.#emitEventInfo({ ...baseInfo, delivered: false, reason });
+        return;
+      }
+      const merged = {
+        ...config.defaultProperties,
+        ...properties
+      };
+      if (config.includeTenantKey && config.tenantKey !== void 0) {
+        merged[config.tenantPropertyName] = config.tenantKey;
+      }
+      const { value: safeProperties, blocked } = sanitizeProperties(
+        merged,
+        config.privacy,
+        this.#logger.child("[privacy]")
+      );
+      this.#logger.debug("Event", {
+        ...baseInfo,
+        properties: safeProperties,
+        ...blocked.length > 0 ? { blockedKeys: blocked } : {}
+      });
+      this.#adapter?.track(event, safeProperties);
+      this.#emitEventInfo({
+        ...baseInfo,
+        delivered: this.#adapter != null,
+        properties: safeProperties,
+        ...blocked.length > 0 ? { blockedKeys: blocked } : {},
+        ...this.#adapter == null ? { reason: "provider not ready" } : {}
+      });
+    } catch (error) {
+      if (error instanceof AnalyticsPrivacyError) {
+        this.#handleError(error);
+        throw error;
+      }
+      this.#handleError(toAnalyticsError(error, "track_failed"));
+    }
+  }
+  pageView(path) {
+    try {
+      if (!this.#initialized || !this.#config) {
+        this.#logger.warn("pageView() called before initialize()");
+        return;
+      }
+      const config = this.#config;
+      const safePath = typeof path === "string" ? stripSensitiveQueryParams(path) : void 0;
+      const baseInfo = {
+        type: "pageview",
+        name: safePath ?? "(current)",
+        provider: config.provider,
+        environment: config.environment,
+        enabled: this.#enabled
+      };
+      if (!this.#enabled) {
+        const reason = config.disabledReason ?? "analytics disabled";
+        this.#logger.debug("Page view skipped", { ...baseInfo, reason });
+        this.#emitEventInfo({ ...baseInfo, delivered: false, reason });
+        return;
+      }
+      this.#logger.debug("Page view", baseInfo);
+      this.#adapter?.pageView(safePath);
+      this.#emitEventInfo({ ...baseInfo, delivered: this.#adapter != null });
+    } catch (error) {
+      this.#handleError(toAnalyticsError(error, "pageview_failed"));
+    }
+  }
+  isEnabled() {
+    return this.#enabled;
+  }
+  isInitialized() {
+    return this.#initialized;
+  }
+  setEnabled(enabled) {
+    if (this.#enabled === enabled) return;
+    this.#enabled = enabled;
+    if (!this.#initialized || !this.#config) {
+      return;
+    }
+    this.#logger.debug(`Analytics ${enabled ? "enabled" : "disabled"} at runtime`);
+    if (enabled && !this.#adapter) {
+      this.#initPromise = this.#startAdapter(this.#config);
+    }
+  }
+  getState() {
+    return {
+      initialized: this.#initialized,
+      enabled: this.#enabled,
+      environment: this.#config?.environment ?? null,
+      provider: this.#config?.provider ?? null,
+      debug: this.#config?.debug ?? false
+    };
+  }
+  destroy() {
+    this.#epoch += 1;
+    this.#teardownAdapter();
+    this.#logger.debug("Analytics destroyed");
+    this.#config = null;
+    this.#signature = null;
+    this.#initialized = false;
+    this.#enabled = false;
+    this.#initPromise = null;
+    this.#logger = createLogger();
+  }
+  #startAdapter(resolved) {
+    let adapter;
+    try {
+      adapter = createAdapter(resolved, { logger: this.#logger });
+    } catch (error) {
+      this.#handleError(toAnalyticsError(error, "initialization_failed"));
+      return Promise.resolve();
+    }
+    this.#adapter = adapter;
+    const epoch = this.#epoch;
+    return (async () => {
+      try {
+        await adapter.initialize();
+        if (this.#epoch !== epoch) return;
+        this.#logger.debug("Provider ready", {
+          provider: adapter.name,
+          environment: resolved.environment
+        });
+      } catch (error) {
+        if (this.#epoch !== epoch) return;
+        this.#handleError(toAnalyticsError(error, "initialization_failed"));
+      }
+    })();
+  }
+  #teardownAdapter() {
+    const adapter = this.#adapter;
+    this.#adapter = null;
+    if (!adapter) return;
+    try {
+      adapter.destroy();
+    } catch (error) {
+      this.#handleError(toAnalyticsError(error, "destroy_failed"));
+    }
+  }
+  #emitEventInfo(info) {
+    const handler = this.#config?.onEvent;
+    if (!handler) return;
+    try {
+      handler(info);
+    } catch (error) {
+      this.#logger.debug("config.onEvent handler threw (ignored)", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  #handleError(error) {
+    this.#logger.error(error.message, { code: error.code });
+    const handler = this.#config?.onError;
+    if (!handler) return;
+    try {
+      handler(error);
+    } catch (handlerError) {
+      this.#logger.debug("config.onError handler threw (ignored)", {
+        error: handlerError instanceof Error ? handlerError.message : String(handlerError)
+      });
+    }
+  }
+};
+function createAnalyticsClient() {
+  return new AnalyticsClientImpl();
+}
+
+export { ANALYTICS_ENVIRONMENTS, AnalyticsConfigError, AnalyticsError, AnalyticsPrivacyError, DEFAULT_PII_KEYS, DEFAULT_SENSITIVE_KEYS, classifyKey, configSignature, createAnalyticsClient, isAnalyticsEnvironment, normalizeKey, sanitizeProperties, stripSensitiveQueryParams, toAnalyticsError };
+//# sourceMappingURL=chunk-J5GXHJNU.js.map
+//# sourceMappingURL=chunk-J5GXHJNU.js.map