@rpcbase/server 0.450.0 → 0.451.0

package/dist/index.js

@@ -4,11 +4,14 @@ import MongoStore from "connect-mongo";
 import { createClient } from "redis";
 import env from "@rpcbase/env";
 import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
-import assert from "assert";
+import { dirname, posix, sep } from "path";
+import { createReadStream, readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { AsyncLocalStorage } from "node:async_hooks";
+import assert$1 from "assert";
 import { hkdfSync, scrypt } from "crypto";
 import { createProxyMiddleware } from "http-proxy-middleware";
 import fs from "node:fs/promises";
-import { readFileSync } from "node:fs";
 import { Transform } from "node:stream";
 import { StrictMode, createElement } from "react";
 import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
@@ -186,8 +189,3068 @@ function requireLib() {
 }
 var libExports = requireLib();
 const requestIp = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+function createModulerModifier() {
+  const getModuleFromFileName = createGetModuleFromFilename();
+  return async (frames) => {
+    for (const frame of frames) frame.module = getModuleFromFileName(frame.filename);
+    return frames;
+  };
+}
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
+  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+  return (filename) => {
+    if (!filename) return;
+    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+    let { dir, base: file, ext } = posix.parse(normalizedFilename);
+    if (".js" === ext || ".mjs" === ext || ".cjs" === ext) file = file.slice(0, -1 * ext.length);
+    const decodedFile = decodeURIComponent(file);
+    if (!dir) dir = ".";
+    const n = dir.lastIndexOf("/node_modules");
+    if (n > -1) return `${dir.slice(n + 14).replace(/\//g, ".")}:${decodedFile}`;
+    if (dir.startsWith(normalizedBase)) {
+      const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, ".");
+      return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+    }
+    return decodedFile;
+  };
+}
+function normalizeWindowsPath(path) {
+  return path.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+}
+const normalizeFlagsResponse = (flagsResponse) => {
+  if ("flags" in flagsResponse) {
+    const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
+    const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
+    return {
+      ...flagsResponse,
+      featureFlags,
+      featureFlagPayloads
+    };
+  }
+  {
+    const featureFlags = flagsResponse.featureFlags ?? {};
+    const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v]) => [
+      k,
+      parsePayload(v)
+    ]));
+    const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
+      key,
+      getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key])
+    ]));
+    return {
+      ...flagsResponse,
+      featureFlags,
+      featureFlagPayloads,
+      flags
+    };
+  }
+};
+function getFlagDetailFromFlagAndPayload(key, value, payload) {
+  return {
+    key,
+    enabled: "string" == typeof value ? true : value,
+    variant: "string" == typeof value ? value : void 0,
+    reason: void 0,
+    metadata: {
+      id: void 0,
+      version: void 0,
+      payload: payload ? JSON.stringify(payload) : void 0,
+      description: void 0
+    }
+  };
+}
+const getFlagValuesFromFlags = (flags) => Object.fromEntries(Object.entries(flags ?? {}).map(([key, detail]) => [
+  key,
+  getFeatureFlagValue(detail)
+]).filter(([, value]) => void 0 !== value));
+const getPayloadsFromFlags = (flags) => {
+  const safeFlags = flags ?? {};
+  return Object.fromEntries(Object.keys(safeFlags).filter((flag) => {
+    const details = safeFlags[flag];
+    return details.enabled && details.metadata && void 0 !== details.metadata.payload;
+  }).map((flag) => {
+    const payload = safeFlags[flag].metadata?.payload;
+    return [
+      flag,
+      payload ? parsePayload(payload) : void 0
+    ];
+  }));
+};
+const getFeatureFlagValue = (detail) => void 0 === detail ? void 0 : detail.variant ?? detail.enabled;
+const parsePayload = (response) => {
+  if ("string" != typeof response) return response;
+  try {
+    return JSON.parse(response);
+  } catch {
+    return response;
+  }
+};
+const DIGITS = "0123456789abcdef";
+class UUID {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  static ofInner(bytes) {
+    if (16 === bytes.length) return new UUID(bytes);
+    throw new TypeError("not 128-bit length");
+  }
+  static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
+    if (!Number.isInteger(unixTsMs) || !Number.isInteger(randA) || !Number.isInteger(randBHi) || !Number.isInteger(randBLo) || unixTsMs < 0 || randA < 0 || randBHi < 0 || randBLo < 0 || unixTsMs > 281474976710655 || randA > 4095 || randBHi > 1073741823 || randBLo > 4294967295) throw new RangeError("invalid field value");
+    const bytes = new Uint8Array(16);
+    bytes[0] = unixTsMs / 2 ** 40;
+    bytes[1] = unixTsMs / 2 ** 32;
+    bytes[2] = unixTsMs / 2 ** 24;
+    bytes[3] = unixTsMs / 2 ** 16;
+    bytes[4] = unixTsMs / 256;
+    bytes[5] = unixTsMs;
+    bytes[6] = 112 | randA >>> 8;
+    bytes[7] = randA;
+    bytes[8] = 128 | randBHi >>> 24;
+    bytes[9] = randBHi >>> 16;
+    bytes[10] = randBHi >>> 8;
+    bytes[11] = randBHi;
+    bytes[12] = randBLo >>> 24;
+    bytes[13] = randBLo >>> 16;
+    bytes[14] = randBLo >>> 8;
+    bytes[15] = randBLo;
+    return new UUID(bytes);
+  }
+  static parse(uuid) {
+    let hex;
+    switch (uuid.length) {
+      case 32:
+        hex = /^[0-9a-f]{32}$/i.exec(uuid)?.[0];
+        break;
+      case 36:
+        hex = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)?.slice(1, 6).join("");
+        break;
+      case 38:
+        hex = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i.exec(uuid)?.slice(1, 6).join("");
+        break;
+      case 45:
+        hex = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)?.slice(1, 6).join("");
+        break;
+    }
+    if (hex) {
+      const inner = new Uint8Array(16);
+      for (let i = 0; i < 16; i += 4) {
+        const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
+        inner[i + 0] = n >>> 24;
+        inner[i + 1] = n >>> 16;
+        inner[i + 2] = n >>> 8;
+        inner[i + 3] = n;
+      }
+      return new UUID(inner);
+    }
+    throw new SyntaxError("could not parse UUID string");
+  }
+  toString() {
+    let text = "";
+    for (let i = 0; i < this.bytes.length; i++) {
+      text += DIGITS.charAt(this.bytes[i] >>> 4);
+      text += DIGITS.charAt(15 & this.bytes[i]);
+      if (3 === i || 5 === i || 7 === i || 9 === i) text += "-";
+    }
+    return text;
+  }
+  toHex() {
+    let text = "";
+    for (let i = 0; i < this.bytes.length; i++) {
+      text += DIGITS.charAt(this.bytes[i] >>> 4);
+      text += DIGITS.charAt(15 & this.bytes[i]);
+    }
+    return text;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  getVariant() {
+    const n = this.bytes[8] >>> 4;
+    if (n < 0) throw new Error("unreachable");
+    if (n <= 7) return this.bytes.every((e) => 0 === e) ? "NIL" : "VAR_0";
+    if (n <= 11) return "VAR_10";
+    if (n <= 13) return "VAR_110";
+    if (n <= 15) return this.bytes.every((e) => 255 === e) ? "MAX" : "VAR_RESERVED";
+    else throw new Error("unreachable");
+  }
+  getVersion() {
+    return "VAR_10" === this.getVariant() ? this.bytes[6] >>> 4 : void 0;
+  }
+  clone() {
+    return new UUID(this.bytes.slice(0));
+  }
+  equals(other) {
+    return 0 === this.compareTo(other);
+  }
+  compareTo(other) {
+    for (let i = 0; i < 16; i++) {
+      const diff = this.bytes[i] - other.bytes[i];
+      if (0 !== diff) return Math.sign(diff);
+    }
+    return 0;
+  }
+}
+class V7Generator {
+  constructor(randomNumberGenerator) {
+    this.timestamp = 0;
+    this.counter = 0;
+    this.random = randomNumberGenerator ?? getDefaultRandom();
+  }
+  generate() {
+    return this.generateOrResetCore(Date.now(), 1e4);
+  }
+  generateOrAbort() {
+    return this.generateOrAbortCore(Date.now(), 1e4);
+  }
+  generateOrResetCore(unixTsMs, rollbackAllowance) {
+    let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+    if (void 0 === value) {
+      this.timestamp = 0;
+      value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+    }
+    return value;
+  }
+  generateOrAbortCore(unixTsMs, rollbackAllowance) {
+    const MAX_COUNTER = 4398046511103;
+    if (!Number.isInteger(unixTsMs) || unixTsMs < 1 || unixTsMs > 281474976710655) throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
+    if (rollbackAllowance < 0 || rollbackAllowance > 281474976710655) throw new RangeError("`rollbackAllowance` out of reasonable range");
+    if (unixTsMs > this.timestamp) {
+      this.timestamp = unixTsMs;
+      this.resetCounter();
+    } else {
+      if (!(unixTsMs + rollbackAllowance >= this.timestamp)) return;
+      this.counter++;
+      if (this.counter > MAX_COUNTER) {
+        this.timestamp++;
+        this.resetCounter();
+      }
+    }
+    return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
+  }
+  resetCounter() {
+    this.counter = 1024 * this.random.nextUint32() + (1023 & this.random.nextUint32());
+  }
+  generateV4() {
+    const bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
+    bytes[6] = 64 | bytes[6] >>> 4;
+    bytes[8] = 128 | bytes[8] >>> 2;
+    return UUID.ofInner(bytes);
+  }
+}
+const getDefaultRandom = () => ({
+  nextUint32: () => 65536 * Math.trunc(65536 * Math.random()) + Math.trunc(65536 * Math.random())
+});
+let defaultGenerator;
+const uuidv7 = () => uuidv7obj().toString();
+const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+const DEFAULT_BLOCKED_UA_STRS = [
+  "amazonbot",
+  "amazonproductbot",
+  "app.hypefactors.com",
+  "applebot",
+  "archive.org_bot",
+  "awariobot",
+  "backlinksextendedbot",
+  "baiduspider",
+  "bingbot",
+  "bingpreview",
+  "chrome-lighthouse",
+  "dataforseobot",
+  "deepscan",
+  "duckduckbot",
+  "facebookexternal",
+  "facebookcatalog",
+  "http://yandex.com/bots",
+  "hubspot",
+  "ia_archiver",
+  "leikibot",
+  "linkedinbot",
+  "meta-externalagent",
+  "mj12bot",
+  "msnbot",
+  "nessus",
+  "petalbot",
+  "pinterest",
+  "prerender",
+  "rogerbot",
+  "screaming frog",
+  "sebot-wa",
+  "sitebulb",
+  "slackbot",
+  "slurp",
+  "trendictionbot",
+  "turnitin",
+  "twitterbot",
+  "vercel-screenshot",
+  "vercelbot",
+  "yahoo! slurp",
+  "yandexbot",
+  "zoombot",
+  "bot.htm",
+  "bot.php",
+  "(bot;",
+  "bot/",
+  "crawler",
+  "ahrefsbot",
+  "ahrefssiteaudit",
+  "semrushbot",
+  "siteauditbot",
+  "splitsignalbot",
+  "gptbot",
+  "oai-searchbot",
+  "chatgpt-user",
+  "perplexitybot",
+  "better uptime bot",
+  "sentryuptimebot",
+  "uptimerobot",
+  "headlesschrome",
+  "cypress",
+  "google-hoteladsverifier",
+  "adsbot-google",
+  "apis-google",
+  "duplexweb-google",
+  "feedfetcher-google",
+  "google favicon",
+  "google web preview",
+  "google-read-aloud",
+  "googlebot",
+  "googleother",
+  "google-cloudvertexbot",
+  "googleweblight",
+  "mediapartners-google",
+  "storebot-google",
+  "google-inspectiontool",
+  "bytespider"
+];
+const isBlockedUA = function(ua, customBlockedUserAgents = []) {
+  if (!ua) return false;
+  const uaLower = ua.toLowerCase();
+  return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents).some((blockedUA) => {
+    const blockedUaLower = blockedUA.toLowerCase();
+    return -1 !== uaLower.indexOf(blockedUaLower);
+  });
+};
+var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedProperty) {
+  PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
+  PostHogPersistedProperty["DistinctId"] = "distinct_id";
+  PostHogPersistedProperty["Props"] = "props";
+  PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
+  PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
+  PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+  PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
+  PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
+  PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
+  PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
+  PostHogPersistedProperty["Queue"] = "queue";
+  PostHogPersistedProperty["OptedOut"] = "opted_out";
+  PostHogPersistedProperty["SessionId"] = "session_id";
+  PostHogPersistedProperty["SessionStartTimestamp"] = "session_start_timestamp";
+  PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
+  PostHogPersistedProperty["PersonProperties"] = "person_properties";
+  PostHogPersistedProperty["GroupProperties"] = "group_properties";
+  PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
+  PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
+  PostHogPersistedProperty["SessionReplay"] = "session_replay";
+  PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
+  PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
+  PostHogPersistedProperty["Surveys"] = "surveys";
+  PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+  PostHogPersistedProperty["FlagsEndpointWasHit"] = "flags_endpoint_was_hit";
+  return PostHogPersistedProperty;
+})({});
+const nativeIsArray = Array.isArray;
+const ObjProto = Object.prototype;
+const type_utils_toString = ObjProto.toString;
+const isArray = nativeIsArray || function(obj) {
+  return "[object Array]" === type_utils_toString.call(obj);
+};
+const isUndefined = (x) => void 0 === x;
+const isString = (x) => "[object String]" == type_utils_toString.call(x);
+const isEmptyString = (x) => isString(x) && 0 === x.trim().length;
+const isNumber = (x) => "[object Number]" == type_utils_toString.call(x);
+const isPlainError = (x) => x instanceof Error;
+function isInstanceOf(candidate, base) {
+  try {
+    return candidate instanceof base;
+  } catch {
+    return false;
+  }
+}
+function isPrimitive(value) {
+  return null === value || "object" != typeof value;
+}
+function isBuiltin(candidate, className) {
+  return Object.prototype.toString.call(candidate) === `[object ${className}]`;
+}
+function isEvent(candidate) {
+  return !isUndefined(Event) && isInstanceOf(candidate, Event);
+}
+function isPlainObject(candidate) {
+  return isBuiltin(candidate, "Object");
+}
+function clampToRange(value, min, max, logger, fallbackValue) {
+  if (min > max) {
+    logger.warn("min cannot be greater than max.");
+    min = max;
+  }
+  if (isNumber(value)) if (value > max) {
+    logger.warn(" cannot be  greater than max: " + max + ". Using max value instead.");
+    return max;
+  } else {
+    if (!(value < min)) return value;
+    logger.warn(" cannot be less than min: " + min + ". Using min value instead.");
+    return min;
+  }
+  logger.warn(" must be a number. using max or fallback. max: " + max + ", fallback: " + fallbackValue);
+  return clampToRange(max, min, max, logger);
+}
+const ONE_DAY_IN_MS = 864e5;
+class BucketedRateLimiter {
+  constructor(options) {
+    this._buckets = {};
+    this._onBucketRateLimited = options._onBucketRateLimited;
+    this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger);
+    this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger);
+    this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
+  }
+  _applyRefill(bucket, now) {
+    const elapsedMs = now - bucket.lastAccess;
+    const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
+    if (refillIntervals > 0) {
+      const tokensToAdd = refillIntervals * this._refillRate;
+      bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
+      bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
+    }
+  }
+  consumeRateLimit(key) {
+    const now = Date.now();
+    const keyStr = String(key);
+    let bucket = this._buckets[keyStr];
+    if (bucket) this._applyRefill(bucket, now);
+    else {
+      bucket = {
+        tokens: this._bucketSize,
+        lastAccess: now
+      };
+      this._buckets[keyStr] = bucket;
+    }
+    if (0 === bucket.tokens) return true;
+    bucket.tokens--;
+    if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
+    return 0 === bucket.tokens;
+  }
+  stop() {
+    this._buckets = {};
+  }
+}
+class PromiseQueue {
+  add(promise) {
+    const promiseUUID = uuidv7();
+    this.promiseByIds[promiseUUID] = promise;
+    promise.catch(() => {
+    }).finally(() => {
+      delete this.promiseByIds[promiseUUID];
+    });
+    return promise;
+  }
+  async join() {
+    let promises = Object.values(this.promiseByIds);
+    let length = promises.length;
+    while (length > 0) {
+      await Promise.all(promises);
+      promises = Object.values(this.promiseByIds);
+      length = promises.length;
+    }
+  }
+  get length() {
+    return Object.keys(this.promiseByIds).length;
+  }
+  constructor() {
+    this.promiseByIds = {};
+  }
+}
+function createConsole(consoleLike = console) {
+  const lockedMethods = {
+    log: consoleLike.log.bind(consoleLike),
+    warn: consoleLike.warn.bind(consoleLike),
+    error: consoleLike.error.bind(consoleLike),
+    debug: consoleLike.debug.bind(consoleLike)
+  };
+  return lockedMethods;
+}
+const _createLogger = (prefix, maybeCall, consoleLike) => {
+  function _log(level, ...args) {
+    maybeCall(() => {
+      const consoleMethod = consoleLike[level];
+      consoleMethod(prefix, ...args);
+    });
+  }
+  const logger = {
+    info: (...args) => {
+      _log("log", ...args);
+    },
+    warn: (...args) => {
+      _log("warn", ...args);
+    },
+    error: (...args) => {
+      _log("error", ...args);
+    },
+    critical: (...args) => {
+      consoleLike["error"](prefix, ...args);
+    },
+    createLogger: (additionalPrefix) => _createLogger(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike)
+  };
+  return logger;
+};
+const passThrough = (fn) => fn();
+function createLogger(prefix, maybeCall = passThrough) {
+  return _createLogger(prefix, maybeCall, createConsole());
+}
+const STRING_FORMAT = "utf8";
+function assert(truthyValue, message) {
+  if (!truthyValue || "string" != typeof truthyValue || isEmpty(truthyValue)) throw new Error(message);
+}
+function isEmpty(truthyValue) {
+  if (0 === truthyValue.trim().length) return true;
+  return false;
+}
+function removeTrailingSlash(url) {
+  return url?.replace(/\/+$/, "");
+}
+async function retriable(fn, props) {
+  let lastError = null;
+  for (let i = 0; i < props.retryCount + 1; i++) {
+    if (i > 0) await new Promise((r) => setTimeout(r, props.retryDelay));
+    try {
+      const res = await fn();
+      return res;
+    } catch (e) {
+      lastError = e;
+      if (!props.retryCheck(e)) throw e;
+    }
+  }
+  throw lastError;
+}
+function currentISOTime() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function safeSetTimeout(fn, timeout) {
+  const t = setTimeout(fn, timeout);
+  t?.unref && t?.unref();
+  return t;
+}
+const isError = (x) => x instanceof Error;
+function allSettled(promises) {
+  return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({
+    status: "fulfilled",
+    value
+  }), (reason) => ({
+    status: "rejected",
+    reason
+  }))));
+}
+class SimpleEventEmitter {
+  constructor() {
+    this.events = {};
+    this.events = {};
+  }
+  on(event, listener) {
+    if (!this.events[event]) this.events[event] = [];
+    this.events[event].push(listener);
+    return () => {
+      this.events[event] = this.events[event].filter((x) => x !== listener);
+    };
+  }
+  emit(event, payload) {
+    for (const listener of this.events[event] || []) listener(payload);
+    for (const listener of this.events["*"] || []) listener(event, payload);
+  }
+}
+function isGzipSupported() {
+  return "CompressionStream" in globalThis;
+}
+async function gzipCompress(input, isDebug = true) {
+  try {
+    const dataStream = new Blob([
+      input
+    ], {
+      type: "text/plain"
+    }).stream();
+    const compressedStream = dataStream.pipeThrough(new CompressionStream("gzip"));
+    return await new Response(compressedStream).blob();
+  } catch (error) {
+    if (isDebug) console.error("Failed to gzip compress data", error);
+    return null;
+  }
+}
+class PostHogFetchHttpError extends Error {
+  constructor(response, reqByteLength) {
+    super("HTTP error while fetching PostHog: status=" + response.status + ", reqByteLength=" + reqByteLength), this.response = response, this.reqByteLength = reqByteLength, this.name = "PostHogFetchHttpError";
+  }
+  get status() {
+    return this.response.status;
+  }
+  get text() {
+    return this.response.text();
+  }
+  get json() {
+    return this.response.json();
+  }
+}
+class PostHogFetchNetworkError extends Error {
+  constructor(error) {
+    super("Network error while fetching PostHog", error instanceof Error ? {
+      cause: error
+    } : {}), this.error = error, this.name = "PostHogFetchNetworkError";
+  }
+}
+async function logFlushError(err) {
+  if (err instanceof PostHogFetchHttpError) {
+    let text = "";
+    try {
+      text = await err.text;
+    } catch {
+    }
+    console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
+  } else console.error("Error while flushing PostHog", err);
+  return Promise.resolve();
+}
+function isPostHogFetchError(err) {
+  return "object" == typeof err && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
+}
+function isPostHogFetchContentTooLargeError(err) {
+  return "object" == typeof err && err instanceof PostHogFetchHttpError && 413 === err.status;
+}
+class PostHogCoreStateless {
+  constructor(apiKey, options = {}) {
+    this.flushPromise = null;
+    this.shutdownPromise = null;
+    this.promiseQueue = new PromiseQueue();
+    this._events = new SimpleEventEmitter();
+    this._isInitialized = false;
+    assert(apiKey, "You must pass your PostHog project's api key.");
+    this.apiKey = apiKey;
+    this.host = removeTrailingSlash(options.host || "https://us.i.posthog.com");
+    this.flushAt = options.flushAt ? Math.max(options.flushAt, 1) : 20;
+    this.maxBatchSize = Math.max(this.flushAt, options.maxBatchSize ?? 100);
+    this.maxQueueSize = Math.max(this.flushAt, options.maxQueueSize ?? 1e3);
+    this.flushInterval = options.flushInterval ?? 1e4;
+    this.preloadFeatureFlags = options.preloadFeatureFlags ?? true;
+    this.defaultOptIn = options.defaultOptIn ?? true;
+    this.disableSurveys = options.disableSurveys ?? false;
+    this._retryOptions = {
+      retryCount: options.fetchRetryCount ?? 3,
+      retryDelay: options.fetchRetryDelay ?? 3e3,
+      retryCheck: isPostHogFetchError
+    };
+    this.requestTimeout = options.requestTimeout ?? 1e4;
+    this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3e3;
+    this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3e3;
+    this.disableGeoip = options.disableGeoip ?? true;
+    this.disabled = options.disabled ?? false;
+    this.historicalMigration = options?.historicalMigration ?? false;
+    this.evaluationEnvironments = options?.evaluationEnvironments;
+    this._initPromise = Promise.resolve();
+    this._isInitialized = true;
+    this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
+    this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
+  }
+  logMsgIfDebug(fn) {
+    if (this.isDebug) fn();
+  }
+  wrap(fn) {
+    if (this.disabled) return void this._logger.warn("The client is disabled");
+    if (this._isInitialized) return fn();
+    this._initPromise.then(() => fn());
+  }
+  getCommonEventProperties() {
+    return {
+      $lib: this.getLibraryId(),
+      $lib_version: this.getLibraryVersion()
+    };
+  }
+  get optedOut() {
+    return this.getPersistedProperty(types_PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
+  }
+  async optIn() {
+    this.wrap(() => {
+      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, false);
+    });
+  }
+  async optOut() {
+    this.wrap(() => {
+      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, true);
+    });
+  }
+  on(event, cb) {
+    return this._events.on(event, cb);
+  }
+  debug(enabled = true) {
+    this.removeDebugCallback?.();
+    if (enabled) {
+      const removeDebugCallback = this.on("*", (event, payload) => this._logger.info(event, payload));
+      this.removeDebugCallback = () => {
+        removeDebugCallback();
+        this.removeDebugCallback = void 0;
+      };
+    }
+  }
+  get isDebug() {
+    return !!this.removeDebugCallback;
+  }
+  get isDisabled() {
+    return this.disabled;
+  }
+  buildPayload(payload) {
+    return {
+      distinct_id: payload.distinct_id,
+      event: payload.event,
+      properties: {
+        ...payload.properties || {},
+        ...this.getCommonEventProperties()
+      }
+    };
+  }
+  addPendingPromise(promise) {
+    return this.promiseQueue.add(promise);
+  }
+  identifyStateless(distinctId, properties, options) {
+    this.wrap(() => {
+      const payload = {
+        ...this.buildPayload({
+          distinct_id: distinctId,
+          event: "$identify",
+          properties
+        })
+      };
+      this.enqueue("identify", payload, options);
+    });
+  }
+  async identifyStatelessImmediate(distinctId, properties, options) {
+    const payload = {
+      ...this.buildPayload({
+        distinct_id: distinctId,
+        event: "$identify",
+        properties
+      })
+    };
+    await this.sendImmediate("identify", payload, options);
+  }
+  captureStateless(distinctId, event, properties, options) {
+    this.wrap(() => {
+      const payload = this.buildPayload({
+        distinct_id: distinctId,
+        event,
+        properties
+      });
+      this.enqueue("capture", payload, options);
+    });
+  }
+  async captureStatelessImmediate(distinctId, event, properties, options) {
+    const payload = this.buildPayload({
+      distinct_id: distinctId,
+      event,
+      properties
+    });
+    await this.sendImmediate("capture", payload, options);
+  }
+  aliasStateless(alias, distinctId, properties, options) {
+    this.wrap(() => {
+      const payload = this.buildPayload({
+        event: "$create_alias",
+        distinct_id: distinctId,
+        properties: {
+          ...properties || {},
+          distinct_id: distinctId,
+          alias
+        }
+      });
+      this.enqueue("alias", payload, options);
+    });
+  }
+  async aliasStatelessImmediate(alias, distinctId, properties, options) {
+    const payload = this.buildPayload({
+      event: "$create_alias",
+      distinct_id: distinctId,
+      properties: {
+        ...properties || {},
+        distinct_id: distinctId,
+        alias
+      }
+    });
+    await this.sendImmediate("alias", payload, options);
+  }
+  groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
+    this.wrap(() => {
+      const payload = this.buildPayload({
+        distinct_id: distinctId || `$${groupType}_${groupKey}`,
+        event: "$groupidentify",
+        properties: {
+          $group_type: groupType,
+          $group_key: groupKey,
+          $group_set: groupProperties || {},
+          ...eventProperties || {}
+        }
+      });
+      this.enqueue("capture", payload, options);
+    });
+  }
+  async getRemoteConfig() {
+    await this._initPromise;
+    let host = this.host;
+    if ("https://us.i.posthog.com" === host) host = "https://us-assets.i.posthog.com";
+    else if ("https://eu.i.posthog.com" === host) host = "https://eu-assets.i.posthog.com";
+    const url = `${host}/array/${this.apiKey}/config`;
+    const fetchOptions = {
+      method: "GET",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json"
+      }
+    };
+    return this.fetchWithRetry(url, fetchOptions, {
+      retryCount: 0
+    }, this.remoteConfigRequestTimeoutMs).then((response) => response.json()).catch((error) => {
+      this._logger.error("Remote config could not be loaded", error);
+      this._events.emit("error", error);
+    });
+  }
+  async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}, fetchConfig = true) {
+    await this._initPromise;
+    const configParam = fetchConfig ? "&config=true" : "";
+    const url = `${this.host}/flags/?v=2${configParam}`;
+    const requestData = {
+      token: this.apiKey,
+      distinct_id: distinctId,
+      groups,
+      person_properties: personProperties,
+      group_properties: groupProperties,
+      ...extraPayload
+    };
+    if (this.evaluationEnvironments && this.evaluationEnvironments.length > 0) requestData.evaluation_environments = this.evaluationEnvironments;
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestData)
+    };
+    this._logger.info("Flags URL", url);
+    return this.fetchWithRetry(url, fetchOptions, {
+      retryCount: 0
+    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => normalizeFlagsResponse(response)).catch((error) => {
+      this._events.emit("error", error);
+    });
+  }
+  async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    await this._initPromise;
+    const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    if (void 0 === flagDetailResponse) return {
+      response: void 0,
+      requestId: void 0
+    };
+    let response = getFeatureFlagValue(flagDetailResponse.response);
+    if (void 0 === response) response = false;
+    return {
+      response,
+      requestId: flagDetailResponse.requestId
+    };
+  }
+  async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    await this._initPromise;
+    const flagsResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
+      key
+    ]);
+    if (void 0 === flagsResponse) return;
+    const featureFlags = flagsResponse.flags;
+    const flagDetail = featureFlags[key];
+    return {
+      response: flagDetail,
+      requestId: flagsResponse.requestId,
+      evaluatedAt: flagsResponse.evaluatedAt
+    };
+  }
+  async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    await this._initPromise;
+    const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
+      key
+    ]);
+    if (!payloads) return;
+    const response = payloads[key];
+    if (void 0 === response) return null;
+    return response;
+  }
+  async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+    await this._initPromise;
+    const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
+    return payloads;
+  }
+  async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+    await this._initPromise;
+    return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+  }
+  async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+    await this._initPromise;
+    const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+    if (!featureFlagDetails) return {
+      flags: void 0,
+      payloads: void 0,
+      requestId: void 0
+    };
+    return {
+      flags: featureFlagDetails.featureFlags,
+      payloads: featureFlagDetails.featureFlagPayloads,
+      requestId: featureFlagDetails.requestId
+    };
+  }
+  async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+    await this._initPromise;
+    const extraPayload = {};
+    if (disableGeoip ?? this.disableGeoip) extraPayload["geoip_disable"] = true;
+    if (flagKeysToEvaluate) extraPayload["flag_keys_to_evaluate"] = flagKeysToEvaluate;
+    const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    if (void 0 === flagsResponse) return;
+    if (flagsResponse.errorsWhileComputingFlags) console.error("[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices");
+    if (flagsResponse.quotaLimited?.includes("feature_flags")) {
+      console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
+      return {
+        flags: {},
+        featureFlags: {},
+        featureFlagPayloads: {},
+        requestId: flagsResponse?.requestId
+      };
+    }
+    return flagsResponse;
+  }
+  async getSurveysStateless() {
+    await this._initPromise;
+    if (true === this.disableSurveys) {
+      this._logger.info("Loading surveys is disabled.");
+      return [];
+    }
+    const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
+    const fetchOptions = {
+      method: "GET",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json"
+      }
+    };
+    const response = await this.fetchWithRetry(url, fetchOptions).then((response2) => {
+      if (200 !== response2.status || !response2.json) {
+        const msg = `Surveys API could not be loaded: ${response2.status}`;
+        const error = new Error(msg);
+        this._logger.error(error);
+        this._events.emit("error", new Error(msg));
+        return;
+      }
+      return response2.json();
+    }).catch((error) => {
+      this._logger.error("Surveys API could not be loaded", error);
+      this._events.emit("error", error);
+    });
+    const newSurveys = response?.surveys;
+    if (newSurveys) this._logger.info("Surveys fetched from API: ", JSON.stringify(newSurveys));
+    return newSurveys ?? [];
+  }
+  get props() {
+    if (!this._props) this._props = this.getPersistedProperty(types_PostHogPersistedProperty.Props);
+    return this._props || {};
+  }
+  set props(val) {
+    this._props = val;
+  }
+  async register(properties) {
+    this.wrap(() => {
+      this.props = {
+        ...this.props,
+        ...properties
+      };
+      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+    });
+  }
+  async unregister(property) {
+    this.wrap(() => {
+      delete this.props[property];
+      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+    });
+  }
+  enqueue(type, _message, options) {
+    this.wrap(() => {
+      if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+      const message = this.prepareMessage(type, _message, options);
+      const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+      if (queue.length >= this.maxQueueSize) {
+        queue.shift();
+        this._logger.info("Queue is full, the oldest event is dropped.");
+      }
+      queue.push({
+        message
+      });
+      this.setPersistedProperty(types_PostHogPersistedProperty.Queue, queue);
+      this._events.emit(type, message);
+      if (queue.length >= this.flushAt) this.flushBackground();
+      if (this.flushInterval && !this._flushTimer) this._flushTimer = safeSetTimeout(() => this.flushBackground(), this.flushInterval);
+    });
+  }
+  async sendImmediate(type, _message, options) {
+    if (this.disabled) return void this._logger.warn("The client is disabled");
+    if (!this._isInitialized) await this._initPromise;
+    if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+    const data = {
+      api_key: this.apiKey,
+      batch: [
+        this.prepareMessage(type, _message, options)
+      ],
+      sent_at: currentISOTime()
+    };
+    if (this.historicalMigration) data.historical_migration = true;
+    const payload = JSON.stringify(data);
+    const url = `${this.host}/batch/`;
+    const gzippedPayload = this.disableCompression ? null : await gzipCompress(payload, this.isDebug);
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json",
+        ...null !== gzippedPayload && {
+          "Content-Encoding": "gzip"
+        }
+      },
+      body: gzippedPayload || payload
+    };
+    try {
+      await this.fetchWithRetry(url, fetchOptions);
+    } catch (err) {
+      this._events.emit("error", err);
+    }
+  }
+  prepareMessage(type, _message, options) {
+    const message = {
+      ..._message,
+      type,
+      library: this.getLibraryId(),
+      library_version: this.getLibraryVersion(),
+      timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+      uuid: options?.uuid ? options.uuid : uuidv7()
+    };
+    const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+    if (addGeoipDisableProperty) {
+      if (!message.properties) message.properties = {};
+      message["properties"]["$geoip_disable"] = true;
+    }
+    if (message.distinctId) {
+      message.distinct_id = message.distinctId;
+      delete message.distinctId;
+    }
+    return message;
+  }
+  clearFlushTimer() {
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = void 0;
+    }
+  }
+  flushBackground() {
+    this.flush().catch(async (err) => {
+      await logFlushError(err);
+    });
+  }
+  async flush() {
+    const nextFlushPromise = allSettled([
+      this.flushPromise
+    ]).then(() => this._flush());
+    this.flushPromise = nextFlushPromise;
+    this.addPendingPromise(nextFlushPromise);
+    allSettled([
+      nextFlushPromise
+    ]).then(() => {
+      if (this.flushPromise === nextFlushPromise) this.flushPromise = null;
+    });
+    return nextFlushPromise;
+  }
+  getCustomHeaders() {
+    const customUserAgent = this.getCustomUserAgent();
+    const headers = {};
+    if (customUserAgent && "" !== customUserAgent) headers["User-Agent"] = customUserAgent;
+    return headers;
+  }
+  async _flush() {
+    this.clearFlushTimer();
+    await this._initPromise;
+    let queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+    if (!queue.length) return;
+    const sentMessages = [];
+    const originalQueueLength = queue.length;
+    while (queue.length > 0 && sentMessages.length < originalQueueLength) {
+      const batchItems = queue.slice(0, this.maxBatchSize);
+      const batchMessages = batchItems.map((item) => item.message);
+      const persistQueueChange = () => {
+        const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+        const newQueue = refreshedQueue.slice(batchItems.length);
+        this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
+        queue = newQueue;
+      };
+      const data = {
+        api_key: this.apiKey,
+        batch: batchMessages,
+        sent_at: currentISOTime()
+      };
+      if (this.historicalMigration) data.historical_migration = true;
+      const payload = JSON.stringify(data);
+      const url = `${this.host}/batch/`;
+      const gzippedPayload = this.disableCompression ? null : await gzipCompress(payload, this.isDebug);
+      const fetchOptions = {
+        method: "POST",
+        headers: {
+          ...this.getCustomHeaders(),
+          "Content-Type": "application/json",
+          ...null !== gzippedPayload && {
+            "Content-Encoding": "gzip"
+          }
+        },
+        body: gzippedPayload || payload
+      };
+      const retryOptions = {
+        retryCheck: (err) => {
+          if (isPostHogFetchContentTooLargeError(err)) return false;
+          return isPostHogFetchError(err);
+        }
+      };
+      try {
+        await this.fetchWithRetry(url, fetchOptions, retryOptions);
+      } catch (err) {
+        if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
+          this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
+          this._logger.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`);
+          continue;
+        }
+        if (!(err instanceof PostHogFetchNetworkError)) persistQueueChange();
+        this._events.emit("error", err);
+        throw err;
+      }
+      persistQueueChange();
+      sentMessages.push(...batchMessages);
+    }
+    this._events.emit("flush", sentMessages);
+  }
+  async fetchWithRetry(url, options, retryOptions, requestTimeout) {
+    AbortSignal.timeout ??= function(ms) {
+      const ctrl = new AbortController();
+      setTimeout(() => ctrl.abort(), ms);
+      return ctrl.signal;
+    };
+    const body = options.body ? options.body : "";
+    let reqByteLength = -1;
+    try {
+      reqByteLength = body instanceof Blob ? body.size : Buffer.byteLength(body, STRING_FORMAT);
+    } catch {
+      if (body instanceof Blob) reqByteLength = body.size;
+      else {
+        const encoded = new TextEncoder().encode(body);
+        reqByteLength = encoded.length;
+      }
+    }
+    return await retriable(async () => {
+      let res = null;
+      try {
+        res = await this.fetch(url, {
+          signal: AbortSignal.timeout(requestTimeout ?? this.requestTimeout),
+          ...options
+        });
+      } catch (e) {
+        throw new PostHogFetchNetworkError(e);
+      }
+      const isNoCors = "no-cors" === options.mode;
+      if (!isNoCors && (res.status < 200 || res.status >= 400)) throw new PostHogFetchHttpError(res, reqByteLength);
+      return res;
+    }, {
+      ...this._retryOptions,
+      ...retryOptions
+    });
+  }
+  async _shutdown(shutdownTimeoutMs = 3e4) {
+    await this._initPromise;
+    let hasTimedOut = false;
+    this.clearFlushTimer();
+    const doShutdown = async () => {
+      try {
+        await this.promiseQueue.join();
+        while (true) {
+          const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+          if (0 === queue.length) break;
+          await this.flush();
+          if (hasTimedOut) break;
+        }
+      } catch (e) {
+        if (!isPostHogFetchError(e)) throw e;
+        await logFlushError(e);
+      }
+    };
+    return Promise.race([
+      new Promise((_, reject) => {
+        safeSetTimeout(() => {
+          this._logger.error("Timed out while shutting down PostHog");
+          hasTimedOut = true;
+          reject("Timeout while shutting down PostHog. Some events may not have been sent.");
+        }, shutdownTimeoutMs);
+      }),
+      doShutdown()
+    ]);
+  }
+  async shutdown(shutdownTimeoutMs = 3e4) {
+    if (this.shutdownPromise) this._logger.warn("shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup");
+    else this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
+      this.shutdownPromise = null;
+    });
+    return this.shutdownPromise;
+  }
+}
+let parsedStackResults;
+let lastKeysCount;
+let cachedFilenameChunkIds;
+function getFilenameToChunkIdMap(stackParser) {
+  const chunkIdMap = globalThis._posthogChunkIds;
+  if (!chunkIdMap) return;
+  const chunkIdKeys = Object.keys(chunkIdMap);
+  if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) return cachedFilenameChunkIds;
+  lastKeysCount = chunkIdKeys.length;
+  cachedFilenameChunkIds = chunkIdKeys.reduce((acc, stackKey) => {
+    if (!parsedStackResults) parsedStackResults = {};
+    const result = parsedStackResults[stackKey];
+    if (result) acc[result[0]] = result[1];
+    else {
+      const parsedStack = stackParser(stackKey);
+      for (let i = parsedStack.length - 1; i >= 0; i--) {
+        const stackFrame = parsedStack[i];
+        const filename = stackFrame?.filename;
+        const chunkId = chunkIdMap[stackKey];
+        if (filename && chunkId) {
+          acc[filename] = chunkId;
+          parsedStackResults[stackKey] = [
+            filename,
+            chunkId
+          ];
+          break;
+        }
+      }
+    }
+    return acc;
+  }, {});
+  return cachedFilenameChunkIds;
+}
+const MAX_CAUSE_RECURSION = 4;
+class ErrorPropertiesBuilder {
+  constructor(coercers, stackParser, modifiers = []) {
+    this.coercers = coercers;
+    this.stackParser = stackParser;
+    this.modifiers = modifiers;
+  }
+  buildFromUnknown(input, hint = {}) {
+    const providedMechanism = hint && hint.mechanism;
+    const mechanism = providedMechanism || {
+      handled: true,
+      type: "generic"
+    };
+    const coercingContext = this.buildCoercingContext(mechanism, hint, 0);
+    const exceptionWithCause = coercingContext.apply(input);
+    const parsingContext = this.buildParsingContext();
+    const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
+    const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
+    return {
+      $exception_list: exceptionList,
+      $exception_level: "error"
+    };
+  }
+  async modifyFrames(exceptionList) {
+    for (const exc of exceptionList) if (exc.stacktrace && exc.stacktrace.frames && isArray(exc.stacktrace.frames)) exc.stacktrace.frames = await this.applyModifiers(exc.stacktrace.frames);
+    return exceptionList;
+  }
+  coerceFallback(ctx) {
+    return {
+      type: "Error",
+      value: "Unknown error",
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
+    };
+  }
+  parseStacktrace(err, ctx) {
+    let cause;
+    if (null != err.cause) cause = this.parseStacktrace(err.cause, ctx);
+    let stack;
+    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? 1 : 0), ctx.chunkIdMap);
+    return {
+      ...err,
+      cause,
+      stack
+    };
+  }
+  applyChunkIds(frames, chunkIdMap) {
+    return frames.map((frame) => {
+      if (frame.filename && chunkIdMap) frame.chunk_id = chunkIdMap[frame.filename];
+      return frame;
+    });
+  }
+  applyCoercers(input, ctx) {
+    for (const adapter of this.coercers) if (adapter.match(input)) return adapter.coerce(input, ctx);
+    return this.coerceFallback(ctx);
+  }
+  async applyModifiers(frames) {
+    let newFrames = frames;
+    for (const modifier of this.modifiers) newFrames = await modifier(newFrames);
+    return newFrames;
+  }
+  convertToExceptionList(exceptionWithStack, mechanism) {
+    const currentException = {
+      type: exceptionWithStack.type,
+      value: exceptionWithStack.value,
+      mechanism: {
+        type: mechanism.type ?? "generic",
+        handled: mechanism.handled ?? true,
+        synthetic: exceptionWithStack.synthetic ?? false
+      }
+    };
+    if (exceptionWithStack.stack) currentException.stacktrace = {
+      type: "raw",
+      frames: exceptionWithStack.stack
+    };
+    const exceptionList = [
+      currentException
+    ];
+    if (null != exceptionWithStack.cause) exceptionList.push(...this.convertToExceptionList(exceptionWithStack.cause, {
+      ...mechanism,
+      handled: true
+    }));
+    return exceptionList;
+  }
+  buildParsingContext() {
+    const context = {
+      chunkIdMap: getFilenameToChunkIdMap(this.stackParser)
+    };
+    return context;
+  }
+  buildCoercingContext(mechanism, hint, depth = 0) {
+    const coerce = (input, depth2) => {
+      if (!(depth2 <= MAX_CAUSE_RECURSION)) return;
+      {
+        const ctx = this.buildCoercingContext(mechanism, hint, depth2);
+        return this.applyCoercers(input, ctx);
+      }
+    };
+    const context = {
+      ...hint,
+      syntheticException: 0 == depth ? hint.syntheticException : void 0,
+      mechanism,
+      apply: (input) => coerce(input, depth),
+      next: (input) => coerce(input, depth + 1)
+    };
+    return context;
+  }
+}
+const UNKNOWN_FUNCTION = "?";
+const FILENAME_MATCH = /^\s*[-]{4,}$/;
+const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+const nodeStackLineParser = (line, platform) => {
+  const lineMatch = line.match(FULL_MATCH);
+  if (lineMatch) {
+    let object;
+    let method;
+    let functionName;
+    let typeName;
+    let methodName;
+    if (lineMatch[1]) {
+      functionName = lineMatch[1];
+      let methodStart = functionName.lastIndexOf(".");
+      if ("." === functionName[methodStart - 1]) methodStart--;
+      if (methodStart > 0) {
+        object = functionName.slice(0, methodStart);
+        method = functionName.slice(methodStart + 1);
+        const objectEnd = object.indexOf(".Module");
+        if (objectEnd > 0) {
+          functionName = functionName.slice(objectEnd + 1);
+          object = object.slice(0, objectEnd);
+        }
+      }
+      typeName = void 0;
+    }
+    if (method) {
+      typeName = object;
+      methodName = method;
+    }
+    if ("<anonymous>" === method) {
+      methodName = void 0;
+      functionName = void 0;
+    }
+    if (void 0 === functionName) {
+      methodName = methodName || UNKNOWN_FUNCTION;
+      functionName = typeName ? `${typeName}.${methodName}` : methodName;
+    }
+    let filename = lineMatch[2]?.startsWith("file://") ? lineMatch[2].slice(7) : lineMatch[2];
+    const isNative = "native" === lineMatch[5];
+    if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
+    if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
+    return {
+      filename: filename ? decodeURI(filename) : void 0,
+      module: void 0,
+      function: functionName,
+      lineno: _parseIntOrUndefined(lineMatch[3]),
+      colno: _parseIntOrUndefined(lineMatch[4]),
+      in_app: filenameIsInApp(filename || "", isNative),
+      platform
+    };
+  }
+  if (line.match(FILENAME_MATCH)) return {
+    filename: line,
+    platform
+  };
+};
+function filenameIsInApp(filename, isNative = false) {
+  const isInternal = isNative || filename && !filename.startsWith("/") && !filename.match(/^[A-Z]:/) && !filename.startsWith(".") && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
+  return !isInternal && void 0 !== filename && !filename.includes("node_modules/");
+}
+function _parseIntOrUndefined(input) {
+  return parseInt(input || "", 10) || void 0;
+}
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STACKTRACE_FRAME_LIMIT = 50;
+function reverseAndStripFrames(stack) {
+  if (!stack.length) return [];
+  const localStack = Array.from(stack);
+  localStack.reverse();
+  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
+    ...frame,
+    filename: frame.filename || getLastStackFrame(localStack).filename,
+    function: frame.function || UNKNOWN_FUNCTION
+  }));
+}
+function getLastStackFrame(arr) {
+  return arr[arr.length - 1] || {};
+}
+function createStackParser(platform, ...parsers) {
+  return (stack, skipFirstLines = 0) => {
+    const frames = [];
+    const lines = stack.split("\n");
+    for (let i = skipFirstLines; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.length > 1024) continue;
+      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+      if (!cleanedLine.match(/\S*Error: /)) {
+        for (const parser of parsers) {
+          const frame = parser(cleanedLine, platform);
+          if (frame) {
+            frames.push(frame);
+            break;
+          }
+        }
+        if (frames.length >= STACKTRACE_FRAME_LIMIT) break;
+      }
+    }
+    return reverseAndStripFrames(frames);
+  };
+}
+class ErrorCoercer {
+  match(err) {
+    return isPlainError(err);
+  }
+  coerce(err, ctx) {
+    return {
+      type: this.getType(err),
+      value: this.getMessage(err, ctx),
+      stack: this.getStack(err),
+      cause: err.cause ? ctx.next(err.cause) : void 0,
+      synthetic: false
+    };
+  }
+  getType(err) {
+    return err.name || err.constructor.name;
+  }
+  getMessage(err, _ctx) {
+    const message = err.message;
+    if (message.error && "string" == typeof message.error.message) return String(message.error.message);
+    return String(message);
+  }
+  getStack(err) {
+    return err.stacktrace || err.stack || void 0;
+  }
+}
+const ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+class StringCoercer {
+  match(input) {
+    return "string" == typeof input;
+  }
+  coerce(input, ctx) {
+    const [type, value] = this.getInfos(input);
+    return {
+      type: type ?? "Error",
+      value: value ?? input,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
+    };
+  }
+  getInfos(candidate) {
+    let type = "Error";
+    let value = candidate;
+    const groups = candidate.match(ERROR_TYPES_PATTERN);
+    if (groups) {
+      type = groups[1];
+      value = groups[2];
+    }
+    return [
+      type,
+      value
+    ];
+  }
+}
+const severityLevels = [
+  "fatal",
+  "error",
+  "warning",
+  "log",
+  "info",
+  "debug"
+];
+function extractExceptionKeysForMessage(err, maxLength = 40) {
+  const keys = Object.keys(err);
+  keys.sort();
+  if (!keys.length) return "[object has no keys]";
+  for (let i = keys.length; i > 0; i--) {
+    const serialized = keys.slice(0, i).join(", ");
+    if (!(serialized.length > maxLength)) {
+      if (i === keys.length) return serialized;
+      return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
+    }
+  }
+  return "";
+}
+class ObjectCoercer {
+  match(candidate) {
+    return "object" == typeof candidate && null !== candidate;
+  }
+  coerce(candidate, ctx) {
+    const errorProperty = this.getErrorPropertyFromObject(candidate);
+    if (errorProperty) return ctx.apply(errorProperty);
+    return {
+      type: this.getType(candidate),
+      value: this.getValue(candidate),
+      stack: ctx.syntheticException?.stack,
+      level: this.isSeverityLevel(candidate.level) ? candidate.level : "error",
+      synthetic: true
+    };
+  }
+  getType(err) {
+    return isEvent(err) ? err.constructor.name : "Error";
+  }
+  getValue(err) {
+    if ("name" in err && "string" == typeof err.name) {
+      let message = `'${err.name}' captured as exception`;
+      if ("message" in err && "string" == typeof err.message) message += ` with message: '${err.message}'`;
+      return message;
+    }
+    if ("message" in err && "string" == typeof err.message) return err.message;
+    const className = this.getObjectClassName(err);
+    const keys = extractExceptionKeysForMessage(err);
+    return `${className && "Object" !== className ? `'${className}'` : "Object"} captured as exception with keys: ${keys}`;
+  }
+  isSeverityLevel(x) {
+    return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
+  }
+  getErrorPropertyFromObject(obj) {
+    for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (isError(value)) return value;
+    }
+  }
+  getObjectClassName(obj) {
+    try {
+      const prototype = Object.getPrototypeOf(obj);
+      return prototype ? prototype.constructor.name : void 0;
+    } catch (e) {
+      return;
+    }
+  }
+}
+class EventCoercer {
+  match(err) {
+    return isEvent(err);
+  }
+  coerce(evt, ctx) {
+    const constructorName = evt.constructor.name;
+    return {
+      type: constructorName,
+      value: `${constructorName} captured as exception with keys: ${extractExceptionKeysForMessage(evt)}`,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
+    };
+  }
+}
+class PrimitiveCoercer {
+  match(candidate) {
+    return isPrimitive(candidate);
+  }
+  coerce(value, ctx) {
+    return {
+      type: "Error",
+      value: `Primitive value captured as exception: ${String(value)}`,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
+    };
+  }
+}
+class ReduceableCache {
+  constructor(_maxSize) {
+    this._maxSize = _maxSize;
+    this._cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (void 0 === value) return;
+    this._cache.delete(key);
+    this._cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+  }
+  reduce() {
+    while (this._cache.size >= this._maxSize) {
+      const value = this._cache.keys().next().value;
+      if (value) this._cache.delete(value);
+    }
+  }
+}
+const LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+const MAX_CONTEXTLINES_COLNO = 1e3;
+const MAX_CONTEXTLINES_LINENO = 1e4;
+async function addSourceContext(frames) {
+  const filesToLines = {};
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const frame = frames[i];
+    const filename = frame?.filename;
+    if (!frame || "string" != typeof filename || "number" != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
+    const filesToLinesOutput = filesToLines[filename];
+    if (!filesToLinesOutput) filesToLines[filename] = [];
+    filesToLines[filename].push(frame.lineno);
+  }
+  const files = Object.keys(filesToLines);
+  if (0 == files.length) return frames;
+  const readlinePromises = [];
+  for (const file of files) {
+    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) continue;
+    const filesToLineRanges = filesToLines[file];
+    if (!filesToLineRanges) continue;
+    filesToLineRanges.sort((a, b) => a - b);
+    const ranges = makeLineReaderRanges(filesToLineRanges);
+    if (ranges.every((r) => rangeExistsInContentCache(file, r))) continue;
+    const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
+    readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
+  }
+  await Promise.all(readlinePromises).catch(() => {
+  });
+  if (frames && frames.length > 0) addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
+  LRU_FILE_CONTENTS_CACHE.reduce();
+  return frames;
+}
+function getContextLinesFromFile(path, ranges, output) {
+  return new Promise((resolve) => {
+    const stream = createReadStream(path);
+    const lineReaded = createInterface({
+      input: stream
+    });
+    function destroyStreamAndResolve() {
+      stream.destroy();
+      resolve();
+    }
+    let lineNumber = 0;
+    let currentRangeIndex = 0;
+    const range = ranges[currentRangeIndex];
+    if (void 0 === range) return void destroyStreamAndResolve();
+    let rangeStart = range[0];
+    let rangeEnd = range[1];
+    function onStreamError() {
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);
+      lineReaded.close();
+      lineReaded.removeAllListeners();
+      destroyStreamAndResolve();
+    }
+    stream.on("error", onStreamError);
+    lineReaded.on("error", onStreamError);
+    lineReaded.on("close", destroyStreamAndResolve);
+    lineReaded.on("line", (line) => {
+      lineNumber++;
+      if (lineNumber < rangeStart) return;
+      output[lineNumber] = snipLine(line, 0);
+      if (lineNumber >= rangeEnd) {
+        if (currentRangeIndex === ranges.length - 1) {
+          lineReaded.close();
+          lineReaded.removeAllListeners();
+          return;
+        }
+        currentRangeIndex++;
+        const range2 = ranges[currentRangeIndex];
+        if (void 0 === range2) {
+          lineReaded.close();
+          lineReaded.removeAllListeners();
+          return;
+        }
+        rangeStart = range2[0];
+        rangeEnd = range2[1];
+      }
+    });
+  });
+}
+function addSourceContextToFrames(frames, cache) {
+  for (const frame of frames) if (frame.filename && void 0 === frame.context_line && "number" == typeof frame.lineno) {
+    const contents = cache.get(frame.filename);
+    if (void 0 === contents) continue;
+    addContextToFrame(frame.lineno, frame, contents);
+  }
+}
+function addContextToFrame(lineno, frame, contents) {
+  if (void 0 === frame.lineno || void 0 === contents) return;
+  frame.pre_context = [];
+  for (let i = makeRangeStart(lineno); i < lineno; i++) {
+    const line = contents[i];
+    if (void 0 === line) return void clearLineContext(frame);
+    frame.pre_context.push(line);
+  }
+  if (void 0 === contents[lineno]) return void clearLineContext(frame);
+  frame.context_line = contents[lineno];
+  const end = makeRangeEnd(lineno);
+  frame.post_context = [];
+  for (let i = lineno + 1; i <= end; i++) {
+    const line = contents[i];
+    if (void 0 === line) break;
+    frame.post_context.push(line);
+  }
+}
+function clearLineContext(frame) {
+  delete frame.pre_context;
+  delete frame.context_line;
+  delete frame.post_context;
+}
+function shouldSkipContextLinesForFile(path) {
+  return path.startsWith("node:") || path.endsWith(".min.js") || path.endsWith(".min.cjs") || path.endsWith(".min.mjs") || path.startsWith("data:");
+}
+function shouldSkipContextLinesForFrame(frame) {
+  if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
+  if (void 0 !== frame.colno && frame.colno > MAX_CONTEXTLINES_COLNO) return true;
+  return false;
+}
+function rangeExistsInContentCache(file, range) {
+  const contents = LRU_FILE_CONTENTS_CACHE.get(file);
+  if (void 0 === contents) return false;
+  for (let i = range[0]; i <= range[1]; i++) if (void 0 === contents[i]) return false;
+  return true;
+}
+function makeLineReaderRanges(lines) {
+  if (!lines.length) return [];
+  let i = 0;
+  const line = lines[0];
+  if ("number" != typeof line) return [];
+  let current = makeContextRange(line);
+  const out = [];
+  while (true) {
+    if (i === lines.length - 1) {
+      out.push(current);
+      break;
+    }
+    const next = lines[i + 1];
+    if ("number" != typeof next) break;
+    if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
+    else {
+      out.push(current);
+      current = makeContextRange(next);
+    }
+    i++;
+  }
+  return out;
+}
+function makeContextRange(line) {
+  return [
+    makeRangeStart(line),
+    makeRangeEnd(line)
+  ];
+}
+function makeRangeStart(line) {
+  return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
+}
+function makeRangeEnd(line) {
+  return line + DEFAULT_LINES_OF_CONTEXT;
+}
+function emplace(map, key, contents) {
+  const value = map.get(key);
+  if (void 0 === value) {
+    map.set(key, contents);
+    return contents;
+  }
+  return value;
+}
+function snipLine(line, colno) {
+  let newLine = line;
+  const lineLength = newLine.length;
+  if (lineLength <= 150) return newLine;
+  if (colno > lineLength) colno = lineLength;
+  let start = Math.max(colno - 60, 0);
+  if (start < 5) start = 0;
+  let end = Math.min(start + 140, lineLength);
+  if (end > lineLength - 5) end = lineLength;
+  if (end === lineLength) start = Math.max(end - 140, 0);
+  newLine = newLine.slice(start, end);
+  if (start > 0) newLine = `...${newLine}`;
+  if (end < lineLength) newLine += "...";
+  return newLine;
+}
+function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
+  let calledFatalError = false;
+  return Object.assign((error) => {
+    const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => "domainUncaughtExceptionClear" !== listener.name && true !== listener._posthogErrorHandler).length;
+    const processWouldExit = 0 === userProvidedListenersCount;
+    captureFn(error, {
+      mechanism: {
+        type: "onuncaughtexception",
+        handled: false
+      }
+    });
+    if (!calledFatalError && processWouldExit) {
+      calledFatalError = true;
+      onFatalFn(error);
+    }
+  }, {
+    _posthogErrorHandler: true
+  });
+}
+function addUncaughtExceptionListener(captureFn, onFatalFn) {
+  globalThis.process?.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
+}
+function addUnhandledRejectionListener(captureFn) {
+  globalThis.process?.on("unhandledRejection", (reason) => captureFn(reason, {
+    mechanism: {
+      type: "onunhandledrejection",
+      handled: false
+    }
+  }));
+}
+const SHUTDOWN_TIMEOUT = 2e3;
+class ErrorTracking {
+  constructor(client2, options, _logger) {
+    this.client = client2;
+    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
+    this._logger = _logger;
+    this._rateLimiter = new BucketedRateLimiter({
+      refillRate: 1,
+      bucketSize: 10,
+      refillInterval: 1e4,
+      _logger: this._logger
+    });
+    this.startAutocaptureIfEnabled();
+  }
+  static async buildEventMessage(error, hint, distinctId, additionalProperties) {
+    const properties = {
+      ...additionalProperties
+    };
+    if (!distinctId) properties.$process_person_profile = false;
+    const exceptionProperties = this.errorPropertiesBuilder.buildFromUnknown(error, hint);
+    exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
+    return {
+      event: "$exception",
+      distinctId: distinctId || uuidv7(),
+      properties: {
+        ...exceptionProperties,
+        ...properties
+      }
+    };
+  }
+  startAutocaptureIfEnabled() {
+    if (this.isEnabled()) {
+      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
+      addUnhandledRejectionListener(this.onException.bind(this));
+    }
+  }
+  onException(exception, hint) {
+    this.client.addPendingPromise((async () => {
+      const eventMessage = await ErrorTracking.buildEventMessage(exception, hint);
+      const exceptionProperties = eventMessage.properties;
+      const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? "Exception";
+      const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
+      if (isRateLimited) return void this._logger.info("Skipping exception capture because of client rate limiting.", {
+        exception: exceptionType
+      });
+      return this.client.capture(eventMessage);
+    })());
+  }
+  async onFatalError(exception) {
+    console.error(exception);
+    await this.client.shutdown(SHUTDOWN_TIMEOUT);
+    process.exit(1);
+  }
+  isEnabled() {
+    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+  }
+  shutdown() {
+    this._rateLimiter.stop();
+  }
+}
+const version = "5.17.2";
+async function hashSHA1(text) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error("SubtleCrypto API not available");
+  const hashBuffer = await subtle.digest("SHA-1", new TextEncoder().encode(text));
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+const SIXTY_SECONDS = 6e4;
+const LONG_SCALE = 1152921504606847e3;
+const NULL_VALUES_ALLOWED_OPERATORS = [
+  "is_not"
+];
+class ClientError extends Error {
+  constructor(message) {
+    super();
+    Error.captureStackTrace(this, this.constructor);
+    this.name = "ClientError";
+    this.message = message;
+    Object.setPrototypeOf(this, ClientError.prototype);
+  }
+}
+class InconclusiveMatchError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
+  }
+}
+class RequiresServerEvaluation extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    Object.setPrototypeOf(this, RequiresServerEvaluation.prototype);
+  }
+}
+class FeatureFlagsPoller {
+  constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }) {
+    this.debugMode = false;
+    this.shouldBeginExponentialBackoff = false;
+    this.backOffCount = 0;
+    this.pollingInterval = pollingInterval;
+    this.personalApiKey = personalApiKey;
+    this.featureFlags = [];
+    this.featureFlagsByKey = {};
+    this.groupTypeMapping = {};
+    this.cohorts = {};
+    this.loadedSuccessfullyOnce = false;
+    this.timeout = timeout;
+    this.projectApiKey = projectApiKey;
+    this.host = host;
+    this.poller = void 0;
+    this.fetch = options.fetch || fetch;
+    this.onError = options.onError;
+    this.customHeaders = customHeaders;
+    this.onLoad = options.onLoad;
+    this.cacheProvider = options.cacheProvider;
+    this.loadFeatureFlags();
+  }
+  debug(enabled = true) {
+    this.debugMode = enabled;
+  }
+  logMsgIfDebug(fn) {
+    if (this.debugMode) fn();
+  }
+  async getFeatureFlag(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
+    await this.loadFeatureFlags();
+    let response;
+    let featureFlag;
+    if (!this.loadedSuccessfullyOnce) return response;
+    featureFlag = this.featureFlagsByKey[key];
+    if (void 0 !== featureFlag) try {
+      const result = await this.computeFlagAndPayloadLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+      response = result.value;
+      this.logMsgIfDebug(() => console.debug(`Successfully computed flag locally: ${key} -> ${response}`));
+    } catch (e) {
+      if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this.logMsgIfDebug(() => console.debug(`${e.name} when computing flag locally: ${key}: ${e.message}`));
+      else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${key}: ${e}`));
+    }
+    return response;
+  }
+  async getAllFlagsAndPayloads(distinctId, groups = {}, personProperties = {}, groupProperties = {}, flagKeysToExplicitlyEvaluate) {
+    await this.loadFeatureFlags();
+    const response = {};
+    const payloads = {};
+    let fallbackToFlags = 0 == this.featureFlags.length;
+    const flagsToEvaluate = flagKeysToExplicitlyEvaluate ? flagKeysToExplicitlyEvaluate.map((key) => this.featureFlagsByKey[key]).filter(Boolean) : this.featureFlags;
+    const sharedEvaluationCache = {};
+    await Promise.all(flagsToEvaluate.map(async (flag) => {
+      try {
+        const { value: matchValue, payload: matchPayload } = await this.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, void 0, sharedEvaluationCache);
+        response[flag.key] = matchValue;
+        if (matchPayload) payloads[flag.key] = matchPayload;
+      } catch (e) {
+        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this.logMsgIfDebug(() => console.debug(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`));
+        else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
+        fallbackToFlags = true;
+      }
+    }));
+    return {
+      response,
+      payloads,
+      fallbackToFlags
+    };
+  }
+  async computeFlagAndPayloadLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, matchValue, evaluationCache, skipLoadCheck = false) {
+    if (!skipLoadCheck) await this.loadFeatureFlags();
+    if (!this.loadedSuccessfullyOnce) return {
+      value: false,
+      payload: null
+    };
+    let flagValue;
+    flagValue = void 0 !== matchValue ? matchValue : await this.computeFlagValueLocally(flag, distinctId, groups, personProperties, groupProperties, evaluationCache);
+    const payload = this.getFeatureFlagPayload(flag.key, flagValue);
+    return {
+      value: flagValue,
+      payload
+    };
+  }
+  async computeFlagValueLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, evaluationCache = {}) {
+    if (flag.ensure_experience_continuity) throw new InconclusiveMatchError("Flag has experience continuity enabled");
+    if (!flag.active) return false;
+    const flagFilters = flag.filters || {};
+    const aggregation_group_type_index = flagFilters.aggregation_group_type_index;
+    if (void 0 == aggregation_group_type_index) return await this.matchFeatureFlagProperties(flag, distinctId, personProperties, evaluationCache);
+    {
+      const groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
+      if (!groupName) {
+        this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${flag.key}`));
+        throw new InconclusiveMatchError("Flag has unknown group type index");
+      }
+      if (!(groupName in groups)) {
+        this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`));
+        return false;
+      }
+      const focusedGroupProperties = groupProperties[groupName];
+      return await this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties, evaluationCache);
+    }
+  }
+  getFeatureFlagPayload(key, flagValue) {
+    let payload = null;
+    if (false !== flagValue && null != flagValue) {
+      if ("boolean" == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue.toString()] || null;
+      else if ("string" == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue] || null;
+      if (null != payload) {
+        if ("object" == typeof payload) return payload;
+        if ("string" == typeof payload) try {
+          return JSON.parse(payload);
+        } catch {
+        }
+        return payload;
+      }
+    }
+    return null;
+  }
+  async evaluateFlagDependency(property, distinctId, properties, evaluationCache) {
+    const targetFlagKey = property.key;
+    if (!this.featureFlagsByKey) throw new InconclusiveMatchError("Feature flags not available for dependency evaluation");
+    if (!("dependency_chain" in property)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' is missing required 'dependency_chain' field`);
+    const dependencyChain = property.dependency_chain;
+    if (!Array.isArray(dependencyChain)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' has an invalid 'dependency_chain' (expected array, got ${typeof dependencyChain})`);
+    if (0 === dependencyChain.length) throw new InconclusiveMatchError(`Circular dependency detected for flag '${targetFlagKey}' (empty dependency chain)`);
+    for (const depFlagKey of dependencyChain) {
+      if (!(depFlagKey in evaluationCache)) {
+        const depFlag = this.featureFlagsByKey[depFlagKey];
+        if (depFlag) if (depFlag.active) try {
+          const depResult = await this.matchFeatureFlagProperties(depFlag, distinctId, properties, evaluationCache);
+          evaluationCache[depFlagKey] = depResult;
+        } catch (error) {
+          throw new InconclusiveMatchError(`Error evaluating flag dependency '${depFlagKey}' for flag '${targetFlagKey}': ${error}`);
+        }
+        else evaluationCache[depFlagKey] = false;
+        else throw new InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`);
+      }
+      const cachedResult = evaluationCache[depFlagKey];
+      if (null == cachedResult) throw new InconclusiveMatchError(`Dependency '${depFlagKey}' could not be evaluated`);
+    }
+    const targetFlagValue = evaluationCache[targetFlagKey];
+    return this.flagEvaluatesToExpectedValue(property.value, targetFlagValue);
+  }
+  flagEvaluatesToExpectedValue(expectedValue, flagValue) {
+    if ("boolean" == typeof expectedValue) return expectedValue === flagValue || "string" == typeof flagValue && "" !== flagValue && true === expectedValue;
+    if ("string" == typeof expectedValue) return flagValue === expectedValue;
+    return false;
+  }
+  async matchFeatureFlagProperties(flag, distinctId, properties, evaluationCache = {}) {
+    const flagFilters = flag.filters || {};
+    const flagConditions = flagFilters.groups || [];
+    let isInconclusive = false;
+    let result;
+    for (const condition of flagConditions) try {
+      if (await this.isConditionMatch(flag, distinctId, condition, properties, evaluationCache)) {
+        const variantOverride = condition.variant;
+        const flagVariants = flagFilters.multivariate?.variants || [];
+        result = variantOverride && flagVariants.some((variant) => variant.key === variantOverride) ? variantOverride : await this.getMatchingVariant(flag, distinctId) || true;
+        break;
+      }
+    } catch (e) {
+      if (e instanceof RequiresServerEvaluation) throw e;
+      if (e instanceof InconclusiveMatchError) isInconclusive = true;
+      else throw e;
+    }
+    if (void 0 !== result) return result;
+    if (isInconclusive) throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
+    return false;
+  }
+  async isConditionMatch(flag, distinctId, condition, properties, evaluationCache = {}) {
+    const rolloutPercentage = condition.rollout_percentage;
+    const warnFunction = (msg) => {
+      this.logMsgIfDebug(() => console.warn(msg));
+    };
+    if ((condition.properties || []).length > 0) {
+      for (const prop of condition.properties) {
+        const propertyType = prop.type;
+        let matches = false;
+        matches = "cohort" === propertyType ? matchCohort(prop, properties, this.cohorts, this.debugMode) : "flag" === propertyType ? await this.evaluateFlagDependency(prop, distinctId, properties, evaluationCache) : matchProperty(prop, properties, warnFunction);
+        if (!matches) return false;
+      }
+      if (void 0 == rolloutPercentage) return true;
+    }
+    if (void 0 != rolloutPercentage && await _hash(flag.key, distinctId) > rolloutPercentage / 100) return false;
+    return true;
+  }
+  async getMatchingVariant(flag, distinctId) {
+    const hashValue = await _hash(flag.key, distinctId, "variant");
+    const matchingVariant = this.variantLookupTable(flag).find((variant) => hashValue >= variant.valueMin && hashValue < variant.valueMax);
+    if (matchingVariant) return matchingVariant.key;
+  }
+  variantLookupTable(flag) {
+    const lookupTable = [];
+    let valueMin = 0;
+    let valueMax = 0;
+    const flagFilters = flag.filters || {};
+    const multivariates = flagFilters.multivariate?.variants || [];
+    multivariates.forEach((variant) => {
+      valueMax = valueMin + variant.rollout_percentage / 100;
+      lookupTable.push({
+        valueMin,
+        valueMax,
+        key: variant.key
+      });
+      valueMin = valueMax;
+    });
+    return lookupTable;
+  }
+  updateFlagState(flagData) {
+    this.featureFlags = flagData.flags;
+    this.featureFlagsByKey = flagData.flags.reduce((acc, curr) => (acc[curr.key] = curr, acc), {});
+    this.groupTypeMapping = flagData.groupTypeMapping;
+    this.cohorts = flagData.cohorts;
+    this.loadedSuccessfullyOnce = true;
+  }
+  async loadFromCache(debugMessage) {
+    if (!this.cacheProvider) return false;
+    try {
+      const cached = await this.cacheProvider.getFlagDefinitions();
+      if (cached) {
+        this.updateFlagState(cached);
+        this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] ${debugMessage} (${cached.flags.length} flags)`));
+        this.onLoad?.(this.featureFlags.length);
+        return true;
+      }
+      return false;
+    } catch (err) {
+      this.onError?.(new Error(`Failed to load from cache: ${err}`));
+      return false;
+    }
+  }
+  async loadFeatureFlags(forceReload = false) {
+    if (this.loadedSuccessfullyOnce && !forceReload) return;
+    if (!this.loadingPromise) this.loadingPromise = this._loadFeatureFlags().catch((err) => this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] Failed to load feature flags: ${err}`))).finally(() => {
+      this.loadingPromise = void 0;
+    });
+    return this.loadingPromise;
+  }
+  isLocalEvaluationReady() {
+    return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
+  }
+  getPollingInterval() {
+    if (!this.shouldBeginExponentialBackoff) return this.pollingInterval;
+    return Math.min(SIXTY_SECONDS, this.pollingInterval * 2 ** this.backOffCount);
+  }
+  async _loadFeatureFlags() {
+    if (this.poller) {
+      clearTimeout(this.poller);
+      this.poller = void 0;
+    }
+    this.poller = setTimeout(() => this.loadFeatureFlags(true), this.getPollingInterval());
+    try {
+      let shouldFetch = true;
+      if (this.cacheProvider) try {
+        shouldFetch = await this.cacheProvider.shouldFetchFlagDefinitions();
+      } catch (err) {
+        this.onError?.(new Error(`Error in shouldFetchFlagDefinitions: ${err}`));
+      }
+      if (!shouldFetch) {
+        const loaded = await this.loadFromCache("Loaded flags from cache (skipped fetch)");
+        if (loaded) return;
+        if (this.loadedSuccessfullyOnce) return;
+      }
+      const res = await this._requestFeatureFlagDefinitions();
+      if (!res) return;
+      switch (res.status) {
+        case 304:
+          this.logMsgIfDebug(() => console.debug("[FEATURE FLAGS] Flags not modified (304), using cached data"));
+          this.flagsEtag = res.headers?.get("ETag") ?? this.flagsEtag;
+          this.loadedSuccessfullyOnce = true;
+          this.shouldBeginExponentialBackoff = false;
+          this.backOffCount = 0;
+          return;
+        case 401:
+          this.shouldBeginExponentialBackoff = true;
+          this.backOffCount += 1;
+          throw new ClientError(`Your project key or personal API key is invalid. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
+        case 402:
+          console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all local flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
+          this.featureFlags = [];
+          this.featureFlagsByKey = {};
+          this.groupTypeMapping = {};
+          this.cohorts = {};
+          return;
+        case 403:
+          this.shouldBeginExponentialBackoff = true;
+          this.backOffCount += 1;
+          throw new ClientError(`Your personal API key does not have permission to fetch feature flag definitions for local evaluation. Setting next polling interval to ${this.getPollingInterval()}ms. Are you sure you're using the correct personal and Project API key pair? More information: https://posthog.com/docs/api/overview`);
+        case 429:
+          this.shouldBeginExponentialBackoff = true;
+          this.backOffCount += 1;
+          throw new ClientError(`You are being rate limited. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
+        case 200: {
+          const responseJson = await res.json() ?? {};
+          if (!("flags" in responseJson)) return void this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
+          this.flagsEtag = res.headers?.get("ETag") ?? void 0;
+          const flagData = {
+            flags: responseJson.flags ?? [],
+            groupTypeMapping: responseJson.group_type_mapping || {},
+            cohorts: responseJson.cohorts || {}
+          };
+          this.updateFlagState(flagData);
+          this.shouldBeginExponentialBackoff = false;
+          this.backOffCount = 0;
+          if (this.cacheProvider && shouldFetch) try {
+            await this.cacheProvider.onFlagDefinitionsReceived(flagData);
+          } catch (err) {
+            this.onError?.(new Error(`Failed to store in cache: ${err}`));
+          }
+          this.onLoad?.(this.featureFlags.length);
+          break;
+        }
+        default:
+          return;
+      }
+    } catch (err) {
+      if (err instanceof ClientError) this.onError?.(err);
+    }
+  }
+  getPersonalApiKeyRequestOptions(method = "GET", etag) {
+    const headers = {
+      ...this.customHeaders,
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.personalApiKey}`
+    };
+    if (etag) headers["If-None-Match"] = etag;
+    return {
+      method,
+      headers
+    };
+  }
+  _requestFeatureFlagDefinitions() {
+    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
+    const options = this.getPersonalApiKeyRequestOptions("GET", this.flagsEtag);
+    let abortTimeout = null;
+    if (this.timeout && "number" == typeof this.timeout) {
+      const controller = new AbortController();
+      abortTimeout = safeSetTimeout(() => {
+        controller.abort();
+      }, this.timeout);
+      options.signal = controller.signal;
+    }
+    try {
+      const fetch1 = this.fetch;
+      return fetch1(url, options);
+    } finally {
+      clearTimeout(abortTimeout);
+    }
+  }
+  async stopPoller(timeoutMs = 3e4) {
+    clearTimeout(this.poller);
+    if (this.cacheProvider) try {
+      const shutdownResult = this.cacheProvider.shutdown();
+      if (shutdownResult instanceof Promise) await Promise.race([
+        shutdownResult,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Cache shutdown timeout after ${timeoutMs}ms`)), timeoutMs))
+      ]);
+    } catch (err) {
+      this.onError?.(new Error(`Error during cache shutdown: ${err}`));
+    }
+  }
+}
+async function _hash(key, distinctId, salt = "") {
+  const hashString = await hashSHA1(`${key}.${distinctId}${salt}`);
+  return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
+}
+function matchProperty(property, propertyValues, warnFunction) {
+  const key = property.key;
+  const value = property.value;
+  const operator = property.operator || "exact";
+  if (key in propertyValues) {
+    if ("is_not_set" === operator) throw new InconclusiveMatchError("Operator is_not_set is not supported");
+  } else throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
+  const overrideValue = propertyValues[key];
+  if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+    if (warnFunction) warnFunction(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
+    return false;
+  }
+  function computeExactMatch(value2, overrideValue2) {
+    if (Array.isArray(value2)) return value2.map((val) => String(val).toLowerCase()).includes(String(overrideValue2).toLowerCase());
+    return String(value2).toLowerCase() === String(overrideValue2).toLowerCase();
+  }
+  function compare(lhs, rhs, operator2) {
+    if ("gt" === operator2) return lhs > rhs;
+    if ("gte" === operator2) return lhs >= rhs;
+    if ("lt" === operator2) return lhs < rhs;
+    if ("lte" === operator2) return lhs <= rhs;
+    throw new Error(`Invalid operator: ${operator2}`);
+  }
+  switch (operator) {
+    case "exact":
+      return computeExactMatch(value, overrideValue);
+    case "is_not":
+      return !computeExactMatch(value, overrideValue);
+    case "is_set":
+      return key in propertyValues;
+    case "icontains":
+      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+    case "not_icontains":
+      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+    case "regex":
+      return isValidRegex(String(value)) && null !== String(overrideValue).match(String(value));
+    case "not_regex":
+      return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      let parsedValue = "number" == typeof value ? value : null;
+      if ("string" == typeof value) try {
+        parsedValue = parseFloat(value);
+      } catch (err) {
+      }
+      if (null == parsedValue || null == overrideValue) return compare(String(overrideValue), String(value), operator);
+      if ("string" == typeof overrideValue) return compare(overrideValue, String(value), operator);
+      return compare(overrideValue, parsedValue, operator);
+    }
+    case "is_date_after":
+    case "is_date_before": {
+      if ("boolean" == typeof value) throw new InconclusiveMatchError("Date operations cannot be performed on boolean values");
+      let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+      if (null == parsedDate) parsedDate = convertToDateTime(value);
+      if (null == parsedDate) throw new InconclusiveMatchError(`Invalid date: ${value}`);
+      const overrideDate = convertToDateTime(overrideValue);
+      if ([
+        "is_date_before"
+      ].includes(operator)) return overrideDate < parsedDate;
+      return overrideDate > parsedDate;
+    }
+    default:
+      throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
+  }
+}
+function checkCohortExists(cohortId, cohortProperties) {
+  if (!(cohortId in cohortProperties)) throw new RequiresServerEvaluation(`cohort ${cohortId} not found in local cohorts - likely a static cohort that requires server evaluation`);
+}
+function matchCohort(property, propertyValues, cohortProperties, debugMode = false) {
+  const cohortId = String(property.value);
+  checkCohortExists(cohortId, cohortProperties);
+  const propertyGroup = cohortProperties[cohortId];
+  return matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode);
+}
+function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode = false) {
+  if (!propertyGroup) return true;
+  const propertyGroupType = propertyGroup.type;
+  const properties = propertyGroup.values;
+  if (!properties || 0 === properties.length) return true;
+  let errorMatchingLocally = false;
+  if ("values" in properties[0]) {
+    for (const prop of properties) try {
+      const matches = matchPropertyGroup(prop, propertyValues, cohortProperties, debugMode);
+      if ("AND" === propertyGroupType) {
+        if (!matches) return false;
+      } else if (matches) return true;
+    } catch (err) {
+      if (err instanceof RequiresServerEvaluation) throw err;
+      if (err instanceof InconclusiveMatchError) {
+        if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
+        errorMatchingLocally = true;
+      } else throw err;
+    }
+    if (errorMatchingLocally) throw new InconclusiveMatchError("Can't match cohort without a given cohort property value");
+    return "AND" === propertyGroupType;
+  }
+  for (const prop of properties) try {
+    let matches;
+    if ("cohort" === prop.type) matches = matchCohort(prop, propertyValues, cohortProperties, debugMode);
+    else if ("flag" === prop.type) {
+      if (debugMode) console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. Skipping condition with dependency on flag '${prop.key || "unknown"}'`);
+      continue;
+    } else matches = matchProperty(prop, propertyValues);
+    const negation = prop.negation || false;
+    if ("AND" === propertyGroupType) {
+      if (!matches && !negation) return false;
+      if (matches && negation) return false;
+    } else {
+      if (matches && !negation) return true;
+      if (!matches && negation) return true;
+    }
+  } catch (err) {
+    if (err instanceof RequiresServerEvaluation) throw err;
+    if (err instanceof InconclusiveMatchError) {
+      if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
+      errorMatchingLocally = true;
+    } else throw err;
+  }
+  if (errorMatchingLocally) throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
+  return "AND" === propertyGroupType;
+}
+function isValidRegex(regex) {
+  try {
+    new RegExp(regex);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function convertToDateTime(value) {
+  if (value instanceof Date) return value;
+  if ("string" == typeof value || "number" == typeof value) {
+    const date = new Date(value);
+    if (!isNaN(date.valueOf())) return date;
+    throw new InconclusiveMatchError(`${value} is in an invalid date format`);
+  }
+  throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
+}
+function relativeDateParseForFeatureFlagMatching(value) {
+  const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
+  const match = value.match(regex);
+  const parsedDt = new Date((/* @__PURE__ */ new Date()).toISOString());
+  if (!match) return null;
+  {
+    if (!match.groups) return null;
+    const number = parseInt(match.groups["number"]);
+    if (number >= 1e4) return null;
+    const interval = match.groups["interval"];
+    if ("h" == interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    else if ("d" == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    else if ("w" == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
+    else if ("m" == interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    else {
+      if ("y" != interval) return null;
+      parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    }
+    return parsedDt;
+  }
+}
+class PostHogMemoryStorage {
+  getProperty(key) {
+    return this._memoryStorage[key];
+  }
+  setProperty(key, value) {
+    this._memoryStorage[key] = null !== value ? value : void 0;
+  }
+  constructor() {
+    this._memoryStorage = {};
+  }
+}
+const MINIMUM_POLLING_INTERVAL = 100;
+const THIRTY_SECONDS = 3e4;
+const MAX_CACHE_SIZE = 5e4;
+class PostHogBackendClient extends PostHogCoreStateless {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options), this._memoryStorage = new PostHogMemoryStorage();
+    this.options = options;
+    this.context = this.initializeContext();
+    this.options.featureFlagsPollingInterval = "number" == typeof options.featureFlagsPollingInterval ? Math.max(options.featureFlagsPollingInterval, MINIMUM_POLLING_INTERVAL) : THIRTY_SECONDS;
+    if (options.personalApiKey) {
+      if (options.personalApiKey.includes("phc_")) throw new Error('Your Personal API key is invalid. These keys are prefixed with "phx_" and can be created in PostHog project settings.');
+      const shouldEnableLocalEvaluation = false !== options.enableLocalEvaluation;
+      if (shouldEnableLocalEvaluation) this.featureFlagsPoller = new FeatureFlagsPoller({
+        pollingInterval: this.options.featureFlagsPollingInterval,
+        personalApiKey: options.personalApiKey,
+        projectApiKey: apiKey,
+        timeout: options.requestTimeout ?? 1e4,
+        host: this.host,
+        fetch: options.fetch,
+        onError: (err) => {
+          this._events.emit("error", err);
+        },
+        onLoad: (count) => {
+          this._events.emit("localEvaluationFlagsLoaded", count);
+        },
+        customHeaders: this.getCustomHeaders(),
+        cacheProvider: options.flagDefinitionCacheProvider
+      });
+    }
+    this.errorTracking = new ErrorTracking(this, options, this._logger);
+    this.distinctIdHasSentFlagCalls = {};
+    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
+  }
+  getPersistedProperty(key) {
+    return this._memoryStorage.getProperty(key);
+  }
+  setPersistedProperty(key, value) {
+    return this._memoryStorage.setProperty(key, value);
+  }
+  fetch(url, options) {
+    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
+  }
+  getLibraryVersion() {
+    return version;
+  }
+  getCustomUserAgent() {
+    return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
+  }
+  enable() {
+    return super.optIn();
+  }
+  disable() {
+    return super.optOut();
+  }
+  debug(enabled = true) {
+    super.debug(enabled);
+    this.featureFlagsPoller?.debug(enabled);
+  }
+  capture(props) {
+    if ("string" == typeof props) this._logger.warn("Called capture() with a string as the first argument when an object was expected.");
+    this.addPendingPromise(this.prepareEventMessage(props).then(({ distinctId, event, properties, options }) => super.captureStateless(distinctId, event, properties, {
+      timestamp: options.timestamp,
+      disableGeoip: options.disableGeoip,
+      uuid: options.uuid
+    })).catch((err) => {
+      if (err) console.error(err);
+    }));
+  }
+  async captureImmediate(props) {
+    if ("string" == typeof props) this._logger.warn("Called captureImmediate() with a string as the first argument when an object was expected.");
+    return this.addPendingPromise(this.prepareEventMessage(props).then(({ distinctId, event, properties, options }) => super.captureStatelessImmediate(distinctId, event, properties, {
+      timestamp: options.timestamp,
+      disableGeoip: options.disableGeoip,
+      uuid: options.uuid
+    })).catch((err) => {
+      if (err) console.error(err);
+    }));
+  }
+  identify({ distinctId, properties, disableGeoip }) {
+    const userPropsOnce = properties?.$set_once;
+    delete properties?.$set_once;
+    const userProps = properties?.$set || properties;
+    super.identifyStateless(distinctId, {
+      $set: userProps,
+      $set_once: userPropsOnce
+    }, {
+      disableGeoip
+    });
+  }
+  async identifyImmediate({ distinctId, properties, disableGeoip }) {
+    const userPropsOnce = properties?.$set_once;
+    delete properties?.$set_once;
+    const userProps = properties?.$set || properties;
+    await super.identifyStatelessImmediate(distinctId, {
+      $set: userProps,
+      $set_once: userPropsOnce
+    }, {
+      disableGeoip
+    });
+  }
+  alias(data) {
+    super.aliasStateless(data.alias, data.distinctId, void 0, {
+      disableGeoip: data.disableGeoip
+    });
+  }
+  async aliasImmediate(data) {
+    await super.aliasStatelessImmediate(data.alias, data.distinctId, void 0, {
+      disableGeoip: data.disableGeoip
+    });
+  }
+  isLocalEvaluationReady() {
+    return this.featureFlagsPoller?.isLocalEvaluationReady() ?? false;
+  }
+  async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
+    if (this.isLocalEvaluationReady()) return true;
+    if (void 0 === this.featureFlagsPoller) return false;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        resolve(false);
+      }, timeoutMs);
+      const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
+        clearTimeout(timeout);
+        cleanup();
+        resolve(count > 0);
+      });
+    });
+  }
+  async getFeatureFlag(key, distinctId, options) {
+    const { groups, disableGeoip } = options || {};
+    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {};
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    personProperties = adjustedProperties.allPersonProperties;
+    groupProperties = adjustedProperties.allGroupProperties;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
+    if (void 0 == sendFeatureFlagEvents) sendFeatureFlagEvents = this.options.sendFeatureFlagEvent ?? true;
+    let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
+    const flagWasLocallyEvaluated = void 0 !== response;
+    let requestId;
+    let evaluatedAt;
+    let flagDetail;
+    if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
+      const remoteResponse = await super.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+      if (void 0 === remoteResponse) return;
+      flagDetail = remoteResponse.response;
+      response = getFeatureFlagValue(flagDetail);
+      requestId = remoteResponse?.requestId;
+      evaluatedAt = remoteResponse?.evaluatedAt;
+    }
+    const featureFlagReportedKey = `${key}_${response}`;
+    if (sendFeatureFlagEvents && (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey))) {
+      if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) this.distinctIdHasSentFlagCalls = {};
+      if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
+      else this.distinctIdHasSentFlagCalls[distinctId] = [
+        featureFlagReportedKey
+      ];
+      this.capture({
+        distinctId,
+        event: "$feature_flag_called",
+        properties: {
+          $feature_flag: key,
+          $feature_flag_response: response,
+          $feature_flag_id: flagDetail?.metadata?.id,
+          $feature_flag_version: flagDetail?.metadata?.version,
+          $feature_flag_reason: flagDetail?.reason?.description ?? flagDetail?.reason?.code,
+          locally_evaluated: flagWasLocallyEvaluated,
+          [`$feature/${key}`]: response,
+          $feature_flag_request_id: requestId,
+          $feature_flag_evaluated_at: evaluatedAt
+        },
+        groups,
+        disableGeoip
+      });
+    }
+    return response;
+  }
+  async getFeatureFlagPayload(key, distinctId, matchValue, options) {
+    const { groups, disableGeoip } = options || {};
+    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    personProperties = adjustedProperties.allPersonProperties;
+    groupProperties = adjustedProperties.allGroupProperties;
+    let response;
+    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
+    if (localEvaluationEnabled) {
+      await this.featureFlagsPoller?.loadFeatureFlags();
+      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
+      if (flag) try {
+        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
+        if (result) {
+          matchValue = result.value;
+          response = result.payload;
+        }
+      } catch (e) {
+        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`);
+        else throw e;
+      }
+    }
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
+    const payloadWasLocallyEvaluated = void 0 !== response;
+    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    return response;
+  }
+  async getRemoteConfigPayload(flagKey) {
+    if (!this.options.personalApiKey) throw new Error("Personal API key is required for remote config payload decryption");
+    const response = await this._requestRemoteConfigPayload(flagKey);
+    if (!response) return;
+    const parsed = await response.json();
+    if ("string" == typeof parsed) try {
+      return JSON.parse(parsed);
+    } catch (e) {
+    }
+    return parsed;
+  }
+  async isFeatureEnabled(key, distinctId, options) {
+    const feat = await this.getFeatureFlag(key, distinctId, options);
+    if (void 0 === feat) return;
+    return !!feat || false;
+  }
+  async getAllFlags(distinctId, options) {
+    const response = await this.getAllFlagsAndPayloads(distinctId, options);
+    return response.featureFlags || {};
+  }
+  async getAllFlagsAndPayloads(distinctId, options) {
+    const { groups, disableGeoip, flagKeys } = options || {};
+    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    personProperties = adjustedProperties.allPersonProperties;
+    groupProperties = adjustedProperties.allGroupProperties;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
+    const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties, flagKeys);
+    let featureFlags = {};
+    let featureFlagPayloads = {};
+    let fallbackToFlags = true;
+    if (localEvaluationResult) {
+      featureFlags = localEvaluationResult.response;
+      featureFlagPayloads = localEvaluationResult.payloads;
+      fallbackToFlags = localEvaluationResult.fallbackToFlags;
+    }
+    if (fallbackToFlags && !onlyEvaluateLocally) {
+      const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeys);
+      featureFlags = {
+        ...featureFlags,
+        ...remoteEvaluationResult.flags || {}
+      };
+      featureFlagPayloads = {
+        ...featureFlagPayloads,
+        ...remoteEvaluationResult.payloads || {}
+      };
+    }
+    return {
+      featureFlags,
+      featureFlagPayloads
+    };
+  }
+  groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }) {
+    super.groupIdentifyStateless(groupType, groupKey, properties, {
+      disableGeoip
+    }, distinctId);
+  }
+  async reloadFeatureFlags() {
+    await this.featureFlagsPoller?.loadFeatureFlags(true);
+  }
+  withContext(data, fn, options) {
+    if (!this.context) return fn();
+    return this.context.run(data, fn, options);
+  }
+  getContext() {
+    return this.context?.get();
+  }
+  async _shutdown(shutdownTimeoutMs) {
+    this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
+    this.errorTracking.shutdown();
+    return super._shutdown(shutdownTimeoutMs);
+  }
+  async _requestRemoteConfigPayload(flagKey) {
+    if (!this.options.personalApiKey) return;
+    const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config?token=${encodeURIComponent(this.apiKey)}`;
+    const options = {
+      method: "GET",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.options.personalApiKey}`
+      }
+    };
+    let abortTimeout = null;
+    if (this.options.requestTimeout && "number" == typeof this.options.requestTimeout) {
+      const controller = new AbortController();
+      abortTimeout = safeSetTimeout(() => {
+        controller.abort();
+      }, this.options.requestTimeout);
+      options.signal = controller.signal;
+    }
+    try {
+      return await this.fetch(url, options);
+    } catch (error) {
+      this._events.emit("error", error);
+      return;
+    } finally {
+      if (abortTimeout) clearTimeout(abortTimeout);
+    }
+  }
+  extractPropertiesFromEvent(eventProperties, groups) {
+    if (!eventProperties) return {
+      personProperties: {},
+      groupProperties: {}
+    };
+    const personProperties = {};
+    const groupProperties = {};
+    for (const [key, value] of Object.entries(eventProperties)) if (isPlainObject(value) && groups && key in groups) {
+      const groupProps = {};
+      for (const [groupKey, groupValue] of Object.entries(value)) groupProps[String(groupKey)] = String(groupValue);
+      groupProperties[String(key)] = groupProps;
+    } else personProperties[String(key)] = String(value);
+    return {
+      personProperties,
+      groupProperties
+    };
+  }
+  async getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions) {
+    const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
+    const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
+    const flagKeys = sendFeatureFlagsOptions?.flagKeys;
+    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
+    if (onlyEvaluateLocally) if (!((this.featureFlagsPoller?.featureFlags?.length || 0) > 0)) return {};
+    else {
+      const groupsWithStringValues = {};
+      for (const [key, value] of Object.entries(groups || {})) groupsWithStringValues[key] = String(value);
+      return await this.getAllFlags(distinctId, {
+        groups: groupsWithStringValues,
+        personProperties: finalPersonProperties,
+        groupProperties: finalGroupProperties,
+        disableGeoip,
+        onlyEvaluateLocally: true,
+        flagKeys
+      });
+    }
+    if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
+      const groupsWithStringValues = {};
+      for (const [key, value] of Object.entries(groups || {})) groupsWithStringValues[key] = String(value);
+      return await this.getAllFlags(distinctId, {
+        groups: groupsWithStringValues,
+        personProperties: finalPersonProperties,
+        groupProperties: finalGroupProperties,
+        disableGeoip,
+        onlyEvaluateLocally: true,
+        flagKeys
+      });
+    }
+    return (await super.getFeatureFlagsStateless(distinctId, groups, finalPersonProperties, finalGroupProperties, disableGeoip)).flags;
+  }
+  addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
+    const allPersonProperties = {
+      distinct_id: distinctId,
+      ...personProperties || {}
+    };
+    const allGroupProperties = {};
+    if (groups) for (const groupName of Object.keys(groups)) allGroupProperties[groupName] = {
+      $group_key: groups[groupName],
+      ...groupProperties?.[groupName] || {}
+    };
+    return {
+      allPersonProperties,
+      allGroupProperties
+    };
+  }
+  captureException(error, distinctId, additionalProperties) {
+    const syntheticException = new Error("PostHog syntheticException");
+    this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
+      syntheticException
+    }, distinctId, additionalProperties).then((msg) => this.capture(msg)));
+  }
+  async captureExceptionImmediate(error, distinctId, additionalProperties) {
+    const syntheticException = new Error("PostHog syntheticException");
+    this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
+      syntheticException
+    }, distinctId, additionalProperties).then((msg) => this.captureImmediate(msg)));
+  }
+  async prepareEventMessage(props) {
+    const { distinctId, event, properties, groups, sendFeatureFlags, timestamp, disableGeoip, uuid } = props;
+    const contextData = this.context?.get();
+    let mergedDistinctId = distinctId || contextData?.distinctId;
+    const mergedProperties = {
+      ...contextData?.properties || {},
+      ...properties || {}
+    };
+    if (!mergedDistinctId) {
+      mergedDistinctId = uuidv7();
+      mergedProperties.$process_person_profile = false;
+    }
+    if (contextData?.sessionId && !mergedProperties.$session_id) mergedProperties.$session_id = contextData.sessionId;
+    const eventMessage = this._runBeforeSend({
+      distinctId: mergedDistinctId,
+      event,
+      properties: mergedProperties,
+      groups,
+      sendFeatureFlags,
+      timestamp,
+      disableGeoip,
+      uuid
+    });
+    if (!eventMessage) return Promise.reject(null);
+    const eventProperties = await Promise.resolve().then(async () => {
+      if (sendFeatureFlags) {
+        const sendFeatureFlagsOptions = "object" == typeof sendFeatureFlags ? sendFeatureFlags : void 0;
+        return await this.getFeatureFlagsForEvent(eventMessage.distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
+      }
+      eventMessage.event;
+      return {};
+    }).then((flags) => {
+      const additionalProperties = {};
+      if (flags) for (const [feature, variant] of Object.entries(flags)) additionalProperties[`$feature/${feature}`] = variant;
+      const activeFlags = Object.keys(flags || {}).filter((flag) => flags?.[flag] !== false).sort();
+      if (activeFlags.length > 0) additionalProperties["$active_feature_flags"] = activeFlags;
+      return additionalProperties;
+    }).catch(() => ({})).then((additionalProperties) => {
+      const props2 = {
+        ...additionalProperties,
+        ...eventMessage.properties || {},
+        $groups: eventMessage.groups || groups
+      };
+      return props2;
+    });
+    if ("$pageview" === eventMessage.event && this.options.__preview_capture_bot_pageviews && "string" == typeof eventProperties.$raw_user_agent) {
+      if (isBlockedUA(eventProperties.$raw_user_agent, this.options.custom_blocked_useragents || [])) {
+        eventMessage.event = "$bot_pageview";
+        eventProperties.$browser_type = "bot";
+      }
+    }
+    return {
+      distinctId: eventMessage.distinctId,
+      event: eventMessage.event,
+      properties: eventProperties,
+      options: {
+        timestamp: eventMessage.timestamp,
+        disableGeoip: eventMessage.disableGeoip,
+        uuid: eventMessage.uuid
+      }
+    };
+  }
+  _runBeforeSend(eventMessage) {
+    const beforeSend = this.options.before_send;
+    if (!beforeSend) return eventMessage;
+    const fns = Array.isArray(beforeSend) ? beforeSend : [
+      beforeSend
+    ];
+    let result = eventMessage;
+    for (const fn of fns) {
+      result = fn(result);
+      if (!result) {
+        this._logger.info(`Event '${eventMessage.event}' was rejected in beforeSend function`);
+        return null;
+      }
+      if (!result.properties || 0 === Object.keys(result.properties).length) {
+        const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
+        this._logger.warn(message);
+      }
+    }
+    return result;
+  }
+}
+class PostHogContext {
+  constructor() {
+    this.storage = new AsyncLocalStorage();
+  }
+  get() {
+    return this.storage.getStore();
+  }
+  run(context, fn, options) {
+    const fresh = options?.fresh === true;
+    if (fresh) return this.storage.run(context, fn);
+    {
+      const currentContext = this.get() || {};
+      const mergedContext = {
+        distinctId: context.distinctId ?? currentContext.distinctId,
+        sessionId: context.sessionId ?? currentContext.sessionId,
+        properties: {
+          ...currentContext.properties || {},
+          ...context.properties || {}
+        }
+      };
+      return this.storage.run(mergedContext, fn);
+    }
+  }
+}
+function setupExpressErrorHandler(_posthog, app) {
+  app.use(posthogErrorHandler(_posthog));
+}
+function posthogErrorHandler(posthog) {
+  return (error, req, res, next) => {
+    const sessionId = req.headers["x-posthog-session-id"];
+    const distinctId = req.headers["x-posthog-distinct-id"];
+    const syntheticException = new Error("Synthetic exception");
+    const hint = {
+      mechanism: {
+        type: "middleware",
+        handled: false
+      },
+      syntheticException
+    };
+    posthog.addPendingPromise(ErrorTracking.buildEventMessage(error, hint, distinctId, {
+      $session_id: sessionId,
+      $current_url: req.url,
+      $request_method: req.method,
+      $request_path: req.path,
+      $user_agent: req.headers["user-agent"],
+      $response_status_code: res.statusCode,
+      $ip: req.headers["x-forwarded-for"] || req?.socket?.remoteAddress
+    }).then((msg) => {
+      posthog.capture(msg);
+    }));
+    next(error);
+  };
+}
+ErrorTracking.errorPropertiesBuilder = new ErrorPropertiesBuilder([
+  new EventCoercer(),
+  new ErrorCoercer(),
+  new ObjectCoercer(),
+  new StringCoercer(),
+  new PrimitiveCoercer()
+], createStackParser("node:javascript", nodeStackLineParser), [
+  createModulerModifier(),
+  addSourceContext
+]);
+class PostHog extends PostHogBackendClient {
+  getLibraryId() {
+    return "posthog-node";
+  }
+  initializeContext() {
+    return new PostHogContext();
+  }
+}
+let client;
+let shutdownHookBound = false;
+const resolveApiKey = (env2) => env2.POSTHOG_API_KEY || env2.POSTHOG_KEY || env2.POSTHOG_SERVER_KEY;
+const resolveHost = (env2) => env2.POSTHOG_HOST || env2.RB_POSTHOG_HOST || "https://eu.i.posthog.com";
+const getPosthogClient = (env2) => {
+  if (client !== void 0) return client;
+  const apiKey = resolveApiKey(env2);
+  if (!apiKey) {
+    client = null;
+    return client;
+  }
+  client = new PostHog(apiKey, {
+    host: resolveHost(env2),
+    enableExceptionAutocapture: true,
+    flushAt: 1,
+    flushInterval: 1e3
+  });
+  return client;
+};
+const bindExpressErrorHandler = (app, posthog) => {
+  if (!posthog) return;
+  setupExpressErrorHandler(posthog, app);
+};
+const captureServerException = (error, posthog, properties) => {
+  const clientToUse = posthog ?? client ?? null;
+  if (!clientToUse || typeof clientToUse.captureException !== "function") return;
+  clientToUse.captureException(error, "server", properties);
+};
+const shutdown = async () => {
+  if (!client) return;
+  try {
+    await client.shutdown();
+  } catch (err) {
+    console.error("posthog shutdown error", err);
+  }
+};
+const ensurePosthogShutdown = () => {
+  if (shutdownHookBound || !client) return;
+  shutdownHookBound = true;
+  const stop = () => {
+    void shutdown();
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  process.on("beforeExit", shutdown);
+};
 const getDerivedKey = (masterKey, info, length = 32, salt = "") => {
-  assert(masterKey?.length >= 32, "MASTER_KEY must be 32 chars or longer.");
+  assert$1(masterKey?.length >= 32, "MASTER_KEY must be 32 chars or longer.");
   return Buffer.from(hkdfSync(
     "sha256",
     masterKey,
@@ -288,6 +3351,12 @@ const initServer = async (app, serverEnv) => {
     next();
   });
   metricsIngestProxyMiddleware(app);
+  const posthog = getPosthogClient(serverEnv);
+  if (posthog) {
+    app.locals.posthog = posthog;
+    bindExpressErrorHandler(app, posthog);
+    ensurePosthogShutdown();
+  }
   if (!serverEnv.MASTER_KEY) {
     throw new Error("MASTER_KEY must be defined to derive the session secret");
   }
@@ -578,12 +3647,23 @@ const ssrMiddleware = ({
   viteInstance,
   dataRoutes,
   errorExtraComponent,
-  renderTemplateStart
+  renderTemplateStart,
+  posthog
 }) => async (req, res, next) => {
   let template;
   let htmlStart = null;
   let htmlEnd = null;
   let responseCommitted = false;
+  const posthogClient = posthog ?? req.app?.locals?.posthog ?? null;
+  const captureException = (error, extra) => {
+    if (!error) return;
+    captureServerException(error, posthogClient, {
+      path: req.originalUrl,
+      method: req.method,
+      source: "ssrMiddleware",
+      ...extra
+    });
+  };
   const finalizeWithErrorPage = (error, status = 500, message = DEFAULT_SERVER_ERROR_MESSAGE) => {
     if (responseCommitted) return;
     sendErrorResponse({
@@ -596,6 +3676,9 @@ const ssrMiddleware = ({
       errorExtraComponent
     });
     responseCommitted = true;
+    if (error) {
+      captureException(error, { phase: "finalizeWithErrorPage" });
+    }
   };
   try {
     const base = "/";
@@ -631,6 +3714,7 @@ const ssrMiddleware = ({
             viteInstance?.ssrFixStacktrace(error);
           }
           console.error("SSR shell error", error);
+          captureException(error, { phase: "shell" });
           finalizeWithErrorPage(error);
           abort();
         },
@@ -640,6 +3724,7 @@ const ssrMiddleware = ({
             viteInstance?.ssrFixStacktrace(error);
           }
           console.error("SSR rendering error", error);
+          captureException(error, { phase: "render" });
         },
         onShellReady() {
           if (responseCommitted) {
@@ -680,6 +3765,7 @@ const ssrMiddleware = ({
     } else {
       console.error("Unknown SSR middleware error", err);
     }
+    captureException(err, { phase: "catch" });
     finalizeWithErrorPage(err);
   }
 };