posthog-node 5.8.8 → 5.9.1

package/dist/edge/index.cjs

@@ -1,3150 +0,0 @@
-'use strict';
-
-var core = require('@posthog/core');
-
-/**
- * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
- */
-/**
- * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
- *
- * ### Usage
- *
- *     Sentry.init({
- *          dsn: 'https://example',
- *          integrations: [
- *              new PostHogSentryIntegration(posthog)
- *          ]
- *     })
- *
- *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
- *
- * @param {Object} [posthog] The posthog object
- * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
- * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
- * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
- * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
- * @param {boolean} [sendExceptionsToPostHog] Optional: capture exceptions as events in PostHog (default: true)
- */
-const NAME = 'posthog-node';
-function createEventProcessor(_posthog, {
-  organization,
-  projectId,
-  prefix,
-  severityAllowList = ['error'],
-  sendExceptionsToPostHog = true
-} = {}) {
-  return event => {
-    const shouldProcessLevel = severityAllowList === '*' || severityAllowList.includes(event.level);
-    if (!shouldProcessLevel) {
-      return event;
-    }
-    if (!event.tags) {
-      event.tags = {};
-    }
-    // Get the PostHog user ID from a specific tag, which users can set on their Sentry scope as they need.
-    const userId = event.tags[PostHogSentryIntegration.POSTHOG_ID_TAG];
-    if (userId === undefined) {
-      // If we can't find a user ID, don't bother linking the event. We won't be able to send anything meaningful to PostHog without it.
-      return event;
-    }
-    const uiHost = _posthog.options.host ?? 'https://us.i.posthog.com';
-    const personUrl = new URL(`/project/${_posthog.apiKey}/person/${userId}`, uiHost).toString();
-    event.tags['PostHog Person URL'] = personUrl;
-    const exceptions = event.exception?.values || [];
-    const exceptionList = exceptions.map(exception => ({
-      ...exception,
-      stacktrace: exception.stacktrace ? {
-        ...exception.stacktrace,
-        type: 'raw',
-        frames: (exception.stacktrace.frames || []).map(frame => {
-          return {
-            ...frame,
-            platform: 'node:javascript'
-          };
-        })
-      } : undefined
-    }));
-    const properties = {
-      // PostHog Exception Properties,
-      $exception_message: exceptions[0]?.value || event.message,
-      $exception_type: exceptions[0]?.type,
-      $exception_personURL: personUrl,
-      $exception_level: event.level,
-      $exception_list: exceptionList,
-      // Sentry Exception Properties
-      $sentry_event_id: event.event_id,
-      $sentry_exception: event.exception,
-      $sentry_exception_message: exceptions[0]?.value || event.message,
-      $sentry_exception_type: exceptions[0]?.type,
-      $sentry_tags: event.tags
-    };
-    if (organization && projectId) {
-      properties['$sentry_url'] = (prefix || 'https://sentry.io/organizations/') + organization + '/issues/?project=' + projectId + '&query=' + event.event_id;
-    }
-    if (sendExceptionsToPostHog) {
-      _posthog.capture({
-        event: '$exception',
-        distinctId: userId,
-        properties
-      });
-    }
-    return event;
-  };
-}
-// V8 integration - function based
-function sentryIntegration(_posthog, options) {
-  const processor = createEventProcessor(_posthog, options);
-  return {
-    name: NAME,
-    processEvent(event) {
-      return processor(event);
-    }
-  };
-}
-// V7 integration - class based
-class PostHogSentryIntegration {
-  constructor(_posthog, organization, prefix, severityAllowList, sendExceptionsToPostHog) {
-    this.name = NAME;
-    // setupOnce gets called by Sentry when it intializes the plugin
-    this.name = NAME;
-    this.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
-      const projectId = getCurrentHub()?.getClient()?.getDsn()?.projectId;
-      addGlobalEventProcessor(createEventProcessor(_posthog, {
-        organization,
-        projectId,
-        prefix,
-        severityAllowList,
-        sendExceptionsToPostHog: sendExceptionsToPostHog ?? true
-      }));
-    };
-  }
-}
-PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';
-
-/*! For license information please see uuidv7.mjs.LICENSE.txt */
-/**
- * uuidv7: An experimental implementation of the proposed UUID Version 7
- *
- * @license Apache-2.0
- * @copyright 2021-2023 LiosK
- * @packageDocumentation
- */ const DIGITS = "0123456789abcdef";
-class UUID {
-    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 > 0xffffffffffff || randA > 0xfff || randBHi > 0x3fffffff || randBLo > 0xffffffff) 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] = 0x70 | randA >>> 8;
-        bytes[7] = randA;
-        bytes[8] = 0x80 | 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:
-                var _exec;
-                hex = null == (_exec = /^[0-9a-f]{32}$/i.exec(uuid)) ? void 0 : _exec[0];
-                break;
-            case 36:
-                var _exec1;
-                hex = null == (_exec1 = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)) ? void 0 : _exec1.slice(1, 6).join("");
-                break;
-            case 38:
-                var _exec2;
-                hex = null == (_exec2 = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i.exec(uuid)) ? void 0 : _exec2.slice(1, 6).join("");
-                break;
-            case 45:
-                var _exec3;
-                hex = null == (_exec3 = /^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)) ? void 0 : _exec3.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(0xf & 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(0xf & 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)=>0xff === 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;
-    }
-    constructor(bytes){
-        this.bytes = bytes;
-    }
-}
-class V7Generator {
-    generate() {
-        return this.generateOrResetCore(Date.now(), 10000);
-    }
-    generateOrAbort() {
-        return this.generateOrAbortCore(Date.now(), 10000);
-    }
-    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 = 0x3ffffffffff;
-        if (!Number.isInteger(unixTsMs) || unixTsMs < 1 || unixTsMs > 0xffffffffffff) throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
-        if (rollbackAllowance < 0 || rollbackAllowance > 0xffffffffffff) 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 = 0x400 * this.random.nextUint32() + (0x3ff & 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] = 0x40 | bytes[6] >>> 4;
-        bytes[8] = 0x80 | bytes[8] >>> 2;
-        return UUID.ofInner(bytes);
-    }
-    constructor(randomNumberGenerator){
-        this.timestamp = 0;
-        this.counter = 0;
-        this.random = null != randomNumberGenerator ? randomNumberGenerator : getDefaultRandom();
-    }
-}
-const getDefaultRandom = ()=>({
-        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random())
-    });
-let defaultGenerator;
-const uuidv7 = ()=>uuidv7obj().toString();
-const uuidv7obj = ()=>(defaultGenerator || (defaultGenerator = new V7Generator())).generate();
-
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
-  let calledFatalError = false;
-  return Object.assign(error => {
-    // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not
-    // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust
-    // exit behaviour of the SDK accordingly:
-    // - If other listeners are attached, do not exit.
-    // - If the only listener attached is ours, exit.
-    const userProvidedListenersCount = global.process.listeners('uncaughtException').filter(listener => {
-      // There are 2 listeners we ignore:
-      return (
-        // as soon as we're using domains this listener is attached by node itself
-        listener.name !== 'domainUncaughtExceptionClear' &&
-        // the handler we register in this integration
-        listener._posthogErrorHandler !== true
-      );
-    }).length;
-    const processWouldExit = userProvidedListenersCount === 0;
-    captureFn(error, {
-      mechanism: {
-        type: 'onuncaughtexception',
-        handled: false
-      }
-    });
-    if (!calledFatalError && processWouldExit) {
-      calledFatalError = true;
-      onFatalFn(error);
-    }
-  }, {
-    _posthogErrorHandler: true
-  });
-}
-function addUncaughtExceptionListener(captureFn, onFatalFn) {
-  global.process.on('uncaughtException', makeUncaughtExceptionHandler(captureFn, onFatalFn));
-}
-function addUnhandledRejectionListener(captureFn) {
-  global.process.on('unhandledRejection', reason => {
-    return captureFn(reason, {
-      mechanism: {
-        type: 'onunhandledrejection',
-        handled: false
-      }
-    });
-  });
-}
-
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-let parsedStackResults;
-let lastKeysCount;
-let cachedFilenameChunkIds;
-function getFilenameToChunkIdMap(stackParser) {
-  const chunkIdMap = globalThis._posthogChunkIds;
-  if (!chunkIdMap) {
-    return null;
-  }
-  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;
-}
-
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-function isEvent(candidate) {
-  return typeof Event !== 'undefined' && isInstanceOf(candidate, Event);
-}
-function isPlainObject(candidate) {
-  return isBuiltin(candidate, 'Object');
-}
-function isError(candidate) {
-  switch (Object.prototype.toString.call(candidate)) {
-    case '[object Error]':
-    case '[object Exception]':
-    case '[object DOMException]':
-    case '[object WebAssembly.Exception]':
-      return true;
-    default:
-      return isInstanceOf(candidate, Error);
-  }
-}
-function isInstanceOf(candidate, base) {
-  try {
-    return candidate instanceof base;
-  } catch {
-    return false;
-  }
-}
-function isErrorEvent(event) {
-  return isBuiltin(event, 'ErrorEvent');
-}
-function isBuiltin(candidate, className) {
-  return Object.prototype.toString.call(candidate) === `[object ${className}]`;
-}
-
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-async function propertiesFromUnknownInput(stackParser, frameModifiers, input, hint) {
-  const providedMechanism = hint && hint.mechanism;
-  const mechanism = providedMechanism || {
-    handled: true,
-    type: 'generic'
-  };
-  const errorList = getErrorList(mechanism, input, hint);
-  const exceptionList = await Promise.all(errorList.map(async error => {
-    const exception = await exceptionFromError(stackParser, frameModifiers, error);
-    exception.value = exception.value || '';
-    exception.type = exception.type || 'Error';
-    exception.mechanism = mechanism;
-    return exception;
-  }));
-  const properties = {
-    $exception_list: exceptionList
-  };
-  return properties;
-}
-// Flatten error causes into a list of errors
-// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
-function getErrorList(mechanism, input, hint) {
-  const error = getError(mechanism, input, hint);
-  if (error.cause) {
-    return [error, ...getErrorList(mechanism, error.cause, hint)];
-  }
-  return [error];
-}
-function getError(mechanism, exception, hint) {
-  if (isError(exception)) {
-    return exception;
-  }
-  mechanism.synthetic = true;
-  if (isPlainObject(exception)) {
-    const errorFromProp = getErrorPropertyFromObject(exception);
-    if (errorFromProp) {
-      return errorFromProp;
-    }
-    const message = getMessageForObject(exception);
-    const ex = hint?.syntheticException || new Error(message);
-    ex.message = message;
-    return ex;
-  }
-  // This handles when someone does: `throw "something awesome";`
-  // We use synthesized Error here so we can extract a (rough) stack trace.
-  const ex = hint?.syntheticException || new Error(exception);
-  ex.message = `${exception}`;
-  return ex;
-}
-/** If a plain object has a property that is an `Error`, return this error. */
-function getErrorPropertyFromObject(obj) {
-  for (const prop in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
-      const value = obj[prop];
-      if (isError(value)) {
-        return value;
-      }
-    }
-  }
-  return undefined;
-}
-function getMessageForObject(exception) {
-  if ('name' in exception && typeof exception.name === 'string') {
-    let message = `'${exception.name}' captured as exception`;
-    if ('message' in exception && typeof exception.message === 'string') {
-      message += ` with message '${exception.message}'`;
-    }
-    return message;
-  } else if ('message' in exception && typeof exception.message === 'string') {
-    return exception.message;
-  }
-  const keys = extractExceptionKeysForMessage(exception);
-  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before
-  // We still want to try to get a decent message for these cases
-  if (isErrorEvent(exception)) {
-    return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
-  }
-  const className = getObjectClassName(exception);
-  return `${className && className !== 'Object' ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
-}
-function getObjectClassName(obj) {
-  try {
-    const prototype = Object.getPrototypeOf(obj);
-    return prototype ? prototype.constructor.name : undefined;
-  } catch (e) {
-    // ignore errors here
-  }
-}
-/**
- * Given any captured exception, extract its keys and create a sorted
- * and truncated list that will be used inside the event message.
- * eg. `Non-error exception captured with keys: foo, bar, baz`
- */
-function extractExceptionKeysForMessage(exception, maxLength = 40) {
-  const keys = Object.keys(convertToPlainObject(exception));
-  keys.sort();
-  const firstKey = keys[0];
-  if (!firstKey) {
-    return '[object has no keys]';
-  }
-  if (firstKey.length >= maxLength) {
-    return truncate(firstKey, maxLength);
-  }
-  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
-    const serialized = keys.slice(0, includedKeys).join(', ');
-    if (serialized.length > maxLength) {
-      continue;
-    }
-    if (includedKeys === keys.length) {
-      return serialized;
-    }
-    return truncate(serialized, maxLength);
-  }
-  return '';
-}
-function truncate(str, max = 0) {
-  if (typeof str !== 'string' || max === 0) {
-    return str;
-  }
-  return str.length <= max ? str : `${str.slice(0, max)}...`;
-}
-/**
- * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
- * non-enumerable properties attached.
- *
- * @param value Initial source that we have to transform in order for it to be usable by the serializer
- * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor
- *  an Error.
- */
-function convertToPlainObject(value) {
-  if (isError(value)) {
-    return {
-      message: value.message,
-      name: value.name,
-      stack: value.stack,
-      ...getOwnProperties(value)
-    };
-  } else if (isEvent(value)) {
-    const newObj = {
-      type: value.type,
-      target: serializeEventTarget(value.target),
-      currentTarget: serializeEventTarget(value.currentTarget),
-      ...getOwnProperties(value)
-    };
-    // TODO: figure out why this fails typing (I think CustomEvent is only supported in Node 19 onwards)
-    // if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
-    //   newObj.detail = (value as unknown as CustomEvent).detail
-    // }
-    return newObj;
-  } else {
-    return value;
-  }
-}
-/** Filters out all but an object's own properties */
-function getOwnProperties(obj) {
-  if (typeof obj === 'object' && obj !== null) {
-    const extractedProps = {};
-    for (const property in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, property)) {
-        extractedProps[property] = obj[property];
-      }
-    }
-    return extractedProps;
-  } else {
-    return {};
-  }
-}
-/** Creates a string representation of the target of an `Event` object */
-function serializeEventTarget(target) {
-  try {
-    return Object.prototype.toString.call(target);
-  } catch (_oO) {
-    return '<unknown>';
-  }
-}
-/**
- * Extracts stack frames from the error and builds an Exception
- */
-async function exceptionFromError(stackParser, frameModifiers, error) {
-  const exception = {
-    type: error.name || error.constructor.name,
-    value: error.message
-  };
-  let frames = parseStackFrames(stackParser, error);
-  for (const modifier of frameModifiers) {
-    frames = await modifier(frames);
-  }
-  if (frames.length) {
-    exception.stacktrace = {
-      frames,
-      type: 'raw'
-    };
-  }
-  return exception;
-}
-/**
- * Extracts stack frames from the error.stack string
- */
-function parseStackFrames(stackParser, error) {
-  return applyChunkIds(stackParser(error.stack || '', 1), stackParser);
-}
-function applyChunkIds(frames, parser) {
-  const filenameChunkIdMap = getFilenameToChunkIdMap(parser);
-  frames.forEach(frame => {
-    if (frame.filename && filenameChunkIdMap) {
-      frame.chunk_id = filenameChunkIdMap[frame.filename];
-    }
-  });
-  return frames;
-}
-
-const ObjProto = Object.prototype;
-const type_utils_toString = ObjProto.toString;
-const isNumber = (x)=>'[object Number]' == type_utils_toString.call(x);
-
-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);
-}
-
-class BucketedRateLimiter {
-    stop() {
-        if (this._removeInterval) {
-            clearInterval(this._removeInterval);
-            this._removeInterval = void 0;
-        }
-    }
-    constructor(_options){
-        this._options = _options;
-        this._buckets = {};
-        this._refillBuckets = ()=>{
-            Object.keys(this._buckets).forEach((key)=>{
-                const newTokens = this._getBucket(key) + this._refillRate;
-                if (newTokens >= this._bucketSize) delete this._buckets[key];
-                else this._setBucket(key, newTokens);
-            });
-        };
-        this._getBucket = (key)=>this._buckets[String(key)];
-        this._setBucket = (key, value)=>{
-            this._buckets[String(key)] = value;
-        };
-        this.consumeRateLimit = (key)=>{
-            var _this__getBucket;
-            let tokens = null != (_this__getBucket = this._getBucket(key)) ? _this__getBucket : this._bucketSize;
-            tokens = Math.max(tokens - 1, 0);
-            if (0 === tokens) return true;
-            this._setBucket(key, tokens);
-            const hasReachedZero = 0 === tokens;
-            if (hasReachedZero) {
-                var _this__onBucketRateLimited, _this;
-                null == (_this__onBucketRateLimited = (_this = this)._onBucketRateLimited) || _this__onBucketRateLimited.call(_this, key);
-            }
-            return hasReachedZero;
-        };
-        this._onBucketRateLimited = this._options._onBucketRateLimited;
-        this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
-        this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
-        this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
-        this._removeInterval = setInterval(()=>{
-            this._refillBuckets();
-        }, this._refillInterval);
-    }
-}
-
-function safeSetTimeout(fn, timeout) {
-    const t = setTimeout(fn, timeout);
-    (null == t ? void 0 : t.unref) && (null == t || t.unref());
-    return t;
-}
-
-const SHUTDOWN_TIMEOUT = 2000;
-class ErrorTracking {
-  constructor(client, options, _logger) {
-    this.client = client;
-    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
-    this._logger = _logger;
-    // by default captures ten exceptions before rate limiting by exception type
-    // refills at a rate of one token / 10 second period
-    // e.g. will capture 1 exception rate limited exception every 10 seconds until burst ends
-    this._rateLimiter = new BucketedRateLimiter({
-      refillRate: 1,
-      bucketSize: 10,
-      refillInterval: 10000,
-      // ten seconds in milliseconds
-      _logger: this._logger
-    });
-    this.startAutocaptureIfEnabled();
-  }
-  static async buildEventMessage(error, hint, distinctId, additionalProperties) {
-    const properties = {
-      ...additionalProperties
-    };
-    // Given stateless nature of Node SDK we capture exceptions using personless processing when no
-    // user can be determined because a distinct_id is not provided e.g. exception autocapture
-    if (!distinctId) {
-      properties.$process_person_profile = false;
-    }
-    const exceptionProperties = await propertiesFromUnknownInput(this.stackParser, this.frameModifiers, error, hint);
-    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));
-    }
-  }
-  async 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) {
-        this._logger.info('Skipping exception capture because of client rate limiting.', {
-          exception: exceptionType
-        });
-        return;
-      }
-      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();
-  }
-}
-
-function setupExpressErrorHandler(_posthog, app) {
-  app.use((error, _, __, next) => {
-    const hint = {
-      mechanism: {
-        type: 'middleware',
-        handled: false
-      }
-    };
-    // Given stateless nature of Node SDK we capture exceptions using personless processing
-    // when no user can be determined e.g. in the case of exception autocapture
-    ErrorTracking.buildEventMessage(error, hint, uuidv7(), {
-      $process_person_profile: false
-    }).then(msg => _posthog.capture(msg));
-    next(error);
-  });
-}
-
-var version = "5.8.8";
-
-/**
- * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
- */
-class Lazy {
-  constructor(factory) {
-    this.factory = factory;
-  }
-  /**
-   * Gets the value, initializing it if necessary.
-   * Multiple concurrent calls will share the same initialization promise.
-   */
-  async getValue() {
-    if (this.value !== undefined) {
-      return this.value;
-    }
-    if (this.initializationPromise === undefined) {
-      this.initializationPromise = (async () => {
-        try {
-          const result = await this.factory();
-          this.value = result;
-          return result;
-        } finally {
-          // Clear the promise so we can retry if needed
-          this.initializationPromise = undefined;
-        }
-      })();
-    }
-    return this.initializationPromise;
-  }
-  /**
-   * Returns true if the value has been initialized.
-   */
-  isInitialized() {
-    return this.value !== undefined;
-  }
-  /**
-   * Returns a promise that resolves when the value is initialized.
-   * If already initialized, resolves immediately.
-   */
-  async waitForInitialization() {
-    if (this.isInitialized()) {
-      return;
-    }
-    await this.getValue();
-  }
-}
-
-/// <reference lib="dom" />
-const nodeCrypto = new Lazy(async () => {
-  try {
-    return await import('crypto');
-  } catch {
-    return undefined;
-  }
-});
-async function getNodeCrypto() {
-  return await nodeCrypto.getValue();
-}
-const webCrypto = new Lazy(async () => {
-  if (typeof globalThis.crypto?.subtle !== 'undefined') {
-    return globalThis.crypto.subtle;
-  }
-  try {
-    // Node.js: use built-in webcrypto and assign it if needed
-    const crypto = await nodeCrypto.getValue();
-    if (crypto?.webcrypto?.subtle) {
-      return crypto.webcrypto.subtle;
-    }
-  } catch {
-    // Ignore if not available
-  }
-  return undefined;
-});
-async function getWebCrypto() {
-  return await webCrypto.getValue();
-}
-
-/// <reference lib="dom" />
-async function hashSHA1(text) {
-  // Try Node.js crypto first
-  const nodeCrypto = await getNodeCrypto();
-  if (nodeCrypto) {
-    return nodeCrypto.createHash('sha1').update(text).digest('hex');
-  }
-  const webCrypto = await getWebCrypto();
-  // Fall back to Web Crypto API
-  if (webCrypto) {
-    const hashBuffer = await webCrypto.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('');
-  }
-  throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API');
-}
-
-const SIXTY_SECONDS = 60 * 1000;
-// eslint-disable-next-line
-const LONG_SCALE = 0xfffffffffffffff;
-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);
-    // instanceof doesn't work in ES3 or ES5
-    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
-    // this is the workaround
-    Object.setPrototypeOf(this, InconclusiveMatchError.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 = undefined;
-    this.fetch = options.fetch || fetch;
-    this.onError = options.onError;
-    this.customHeaders = customHeaders;
-    this.onLoad = options.onLoad;
-    void 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 = undefined;
-    let featureFlag = undefined;
-    if (!this.loadedSuccessfullyOnce) {
-      return response;
-    }
-    featureFlag = this.featureFlagsByKey[key];
-    if (featureFlag !== undefined) {
-      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 InconclusiveMatchError) {
-          this.logMsgIfDebug(() => console.debug(`InconclusiveMatchError when computing flag locally: ${key}: ${e}`));
-        } 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 = this.featureFlags.length == 0;
-    const flagsToEvaluate = flagKeysToExplicitlyEvaluate ? flagKeysToExplicitlyEvaluate.map(key => this.featureFlagsByKey[key]).filter(Boolean) : this.featureFlags;
-    // Create a shared evaluation cache to prevent memory leaks when processing many flags
-    const sharedEvaluationCache = {};
-    await Promise.all(flagsToEvaluate.map(async flag => {
-      try {
-        const {
-          value: matchValue,
-          payload: matchPayload
-        } = await this.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, undefined /* matchValue */, sharedEvaluationCache);
-        response[flag.key] = matchValue;
-        if (matchPayload) {
-          payloads[flag.key] = matchPayload;
-        }
-      } catch (e) {
-        if (e instanceof InconclusiveMatchError) {
-          this.logMsgIfDebug(() => console.debug(`InconclusiveMatchError when computing flag locally: ${flag.key}: ${e}`));
-        } 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) {
-    // Only load flags if not already loaded and not skipping the check
-    if (!skipLoadCheck) {
-      await this.loadFeatureFlags();
-    }
-    if (!this.loadedSuccessfullyOnce) {
-      return {
-        value: false,
-        payload: null
-      };
-    }
-    let flagValue;
-    // If matchValue is provided, use it directly; otherwise evaluate the flag
-    if (matchValue !== undefined) {
-      flagValue = matchValue;
-    } else {
-      flagValue = await this.computeFlagValueLocally(flag, distinctId, groups, personProperties, groupProperties, evaluationCache);
-    }
-    // Always compute payload based on the final flagValue (whether provided or computed)
-    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 (aggregation_group_type_index != undefined) {
-      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);
-    } else {
-      return await this.matchFeatureFlagProperties(flag, distinctId, personProperties, evaluationCache);
-    }
-  }
-  getFeatureFlagPayload(key, flagValue) {
-    let payload = null;
-    if (flagValue !== false && flagValue !== null && flagValue !== undefined) {
-      if (typeof flagValue == 'boolean') {
-        payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue.toString()] || null;
-      } else if (typeof flagValue == 'string') {
-        payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue] || null;
-      }
-      if (payload !== null && payload !== undefined) {
-        // If payload is already an object, return it directly
-        if (typeof payload === 'object') {
-          return payload;
-        }
-        // If payload is a string, try to parse it as JSON
-        if (typeof payload === 'string') {
-          try {
-            return JSON.parse(payload);
-          } catch {
-            // If parsing fails, return the string as is
-            return payload;
-          }
-        }
-        // For other types, return as is
-        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');
-    }
-    // Check if dependency_chain is present - it should always be provided for flag dependencies
-    if (!('dependency_chain' in property)) {
-      throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' is missing required 'dependency_chain' field`);
-    }
-    const dependencyChain = property.dependency_chain;
-    // Check for missing or invalid dependency chain (This should never happen, but being defensive)
-    if (!Array.isArray(dependencyChain)) {
-      throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' has an invalid 'dependency_chain' (expected array, got ${typeof dependencyChain})`);
-    }
-    // Handle circular dependency (empty chain means circular)  (This should never happen, but being defensive)
-    if (dependencyChain.length === 0) {
-      throw new InconclusiveMatchError(`Circular dependency detected for flag '${targetFlagKey}' (empty dependency chain)`);
-    }
-    // Evaluate all dependencies in the chain order
-    for (const depFlagKey of dependencyChain) {
-      if (!(depFlagKey in evaluationCache)) {
-        // Need to evaluate this dependency first
-        const depFlag = this.featureFlagsByKey[depFlagKey];
-        if (!depFlag) {
-          // Missing flag dependency - cannot evaluate locally
-          throw new InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`);
-        } else if (!depFlag.active) {
-          // Inactive flag evaluates to false
-          evaluationCache[depFlagKey] = false;
-        } else {
-          // Recursively evaluate the dependency
-          try {
-            const depResult = await this.matchFeatureFlagProperties(depFlag, distinctId, properties, evaluationCache);
-            evaluationCache[depFlagKey] = depResult;
-          } catch (error) {
-            // If we can't evaluate a dependency, store throw InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`)
-            throw new InconclusiveMatchError(`Error evaluating flag dependency '${depFlagKey}' for flag '${targetFlagKey}': ${error}`);
-          }
-        }
-      }
-      // Check if dependency evaluation was inconclusive
-      const cachedResult = evaluationCache[depFlagKey];
-      if (cachedResult === null || cachedResult === undefined) {
-        throw new InconclusiveMatchError(`Dependency '${depFlagKey}' could not be evaluated`);
-      }
-    }
-    // The target flag is specified in property.key (This should match the last element in the dependency chain)
-    const targetFlagValue = evaluationCache[targetFlagKey];
-    return this.flagEvaluatesToExpectedValue(property.value, targetFlagValue);
-  }
-  flagEvaluatesToExpectedValue(expectedValue, flagValue) {
-    // If the expected value is a boolean, then return true if the flag evaluated to true (or any string variant)
-    // If the expected value is false, then only return true if the flag evaluated to false.
-    if (typeof expectedValue === 'boolean') {
-      return expectedValue === flagValue || typeof flagValue === 'string' && flagValue !== '' && expectedValue === true;
-    }
-    // If the expected value is a string, then return true if and only if the flag evaluated to the expected value.
-    if (typeof expectedValue === 'string') {
-      return flagValue === expectedValue;
-    }
-    // The `flag_evaluates_to` operator is not supported for numbers and arrays.
-    return false;
-  }
-  async matchFeatureFlagProperties(flag, distinctId, properties, evaluationCache = {}) {
-    const flagFilters = flag.filters || {};
-    const flagConditions = flagFilters.groups || [];
-    let isInconclusive = false;
-    let result = undefined;
-    for (const condition of flagConditions) {
-      try {
-        if (await this.isConditionMatch(flag, distinctId, condition, properties, evaluationCache)) {
-          const variantOverride = condition.variant;
-          const flagVariants = flagFilters.multivariate?.variants || [];
-          if (variantOverride && flagVariants.some(variant => variant.key === variantOverride)) {
-            result = variantOverride;
-          } else {
-            result = (await this.getMatchingVariant(flag, distinctId)) || true;
-          }
-          break;
-        }
-      } catch (e) {
-        if (e instanceof InconclusiveMatchError) {
-          isInconclusive = true;
-        } else {
-          throw e;
-        }
-      }
-    }
-    if (result !== undefined) {
-      return result;
-    } else if (isInconclusive) {
-      throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
-    }
-    // We can only return False when all conditions are False
-    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;
-        if (propertyType === 'cohort') {
-          matches = matchCohort(prop, properties, this.cohorts, this.debugMode);
-        } else if (propertyType === 'flag') {
-          matches = await this.evaluateFlagDependency(prop, distinctId, properties, evaluationCache);
-        } else {
-          matches = matchProperty(prop, properties, warnFunction);
-        }
-        if (!matches) {
-          return false;
-        }
-      }
-      if (rolloutPercentage == undefined) {
-        return true;
-      }
-    }
-    if (rolloutPercentage != undefined && (await _hash(flag.key, distinctId)) > rolloutPercentage / 100.0) {
-      return false;
-    }
-    return true;
-  }
-  async getMatchingVariant(flag, distinctId) {
-    const hashValue = await _hash(flag.key, distinctId, 'variant');
-    const matchingVariant = this.variantLookupTable(flag).find(variant => {
-      return hashValue >= variant.valueMin && hashValue < variant.valueMax;
-    });
-    if (matchingVariant) {
-      return matchingVariant.key;
-    }
-    return undefined;
-  }
-  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.0;
-      lookupTable.push({
-        valueMin,
-        valueMax,
-        key: variant.key
-      });
-      valueMin = valueMax;
-    });
-    return lookupTable;
-  }
-  async loadFeatureFlags(forceReload = false) {
-    if (!this.loadedSuccessfullyOnce || forceReload) {
-      await this._loadFeatureFlags();
-    }
-  }
-  /**
-   * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
-   * This is useful to check if local evaluation is ready before calling getFeatureFlag.
-   */
-  isLocalEvaluationReady() {
-    return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
-  }
-  /**
-   * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
-   * until a successful request is made, up to a maximum of 60 seconds.
-   *
-   * @returns The polling interval to use for the next request.
-   */
-  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 = undefined;
-    }
-    this.poller = setTimeout(() => this._loadFeatureFlags(), this.getPollingInterval());
-    try {
-      const res = await this._requestFeatureFlagDefinitions();
-      // Handle undefined res case, this shouldn't happen, but it doesn't hurt to handle it anyway
-      if (!res) {
-        // Don't override existing flags when something goes wrong
-        return;
-      }
-      // NB ON ERROR HANDLING & `loadedSuccessfullyOnce`:
-      //
-      // `loadedSuccessfullyOnce` indicates we've successfully loaded a valid set of flags at least once.
-      // If we set it to `true` in an error scenario (e.g. 402 Over Quota, 401 Invalid Key, etc.),
-      // any manual call to `loadFeatureFlags()` (without forceReload) will skip refetching entirely,
-      // leaving us stuck with zero or outdated flags. The poller does keep running, but we also want
-      // manual reloads to be possible as soon as the error condition is resolved.
-      //
-      // Therefore, on error statuses, we do *not* set `loadedSuccessfullyOnce = true`, ensuring that
-      // both the background poller and any subsequent manual calls can keep trying to load flags
-      // once the issue (quota, permission, rate limit, etc.) is resolved.
-      switch (res.status) {
-        case 401:
-          // Invalid API key
-          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:
-          // Quota exceeded - clear all flags
-          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:
-          // Permissions issue
-          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:
-          // Rate limited
-          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:
-          {
-            // Process successful response
-            const responseJson = (await res.json()) ?? {};
-            if (!('flags' in responseJson)) {
-              this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
-              return;
-            }
-            this.featureFlags = responseJson.flags ?? [];
-            this.featureFlagsByKey = this.featureFlags.reduce((acc, curr) => (acc[curr.key] = curr, acc), {});
-            this.groupTypeMapping = responseJson.group_type_mapping || {};
-            this.cohorts = responseJson.cohorts || {};
-            this.loadedSuccessfullyOnce = true;
-            this.shouldBeginExponentialBackoff = false;
-            this.backOffCount = 0;
-            this.onLoad?.(this.featureFlags.length);
-            break;
-          }
-        default:
-          // Something else went wrong, or the server is down.
-          // In this case, don't override existing flags
-          return;
-      }
-    } catch (err) {
-      if (err instanceof ClientError) {
-        this.onError?.(err);
-      }
-    }
-  }
-  getPersonalApiKeyRequestOptions(method = 'GET') {
-    return {
-      method,
-      headers: {
-        ...this.customHeaders,
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.personalApiKey}`
-      }
-    };
-  }
-  async _requestFeatureFlagDefinitions() {
-    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
-    const options = this.getPersonalApiKeyRequestOptions();
-    let abortTimeout = null;
-    if (this.timeout && typeof this.timeout === 'number') {
-      const controller = new AbortController();
-      abortTimeout = safeSetTimeout(() => {
-        controller.abort();
-      }, this.timeout);
-      options.signal = controller.signal;
-    }
-    try {
-      return await this.fetch(url, options);
-    } finally {
-      clearTimeout(abortTimeout);
-    }
-  }
-  stopPoller() {
-    clearTimeout(this.poller);
-  }
-}
-// # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
-// # Given the same distinct_id and key, it'll always return the same float. These floats are
-// # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
-// # we can do _hash(key, distinct_id) < 0.2
-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)) {
-    throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
-  } else if (operator === 'is_not_set') {
-    throw new InconclusiveMatchError(`Operator is_not_set is not supported`);
-  }
-  const overrideValue = propertyValues[key];
-  if (overrideValue == null && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
-    // if the value is null, just fail the feature flag comparison
-    // this isn't an InconclusiveMatchError because the property value was provided.
-    if (warnFunction) {
-      warnFunction(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
-    }
-    return false;
-  }
-  function computeExactMatch(value, overrideValue) {
-    if (Array.isArray(value)) {
-      return value.map(val => String(val).toLowerCase()).includes(String(overrideValue).toLowerCase());
-    }
-    return String(value).toLowerCase() === String(overrideValue).toLowerCase();
-  }
-  function compare(lhs, rhs, operator) {
-    if (operator === 'gt') {
-      return lhs > rhs;
-    } else if (operator === 'gte') {
-      return lhs >= rhs;
-    } else if (operator === 'lt') {
-      return lhs < rhs;
-    } else if (operator === 'lte') {
-      return lhs <= rhs;
-    } else {
-      throw new Error(`Invalid operator: ${operator}`);
-    }
-  }
-  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)) && String(overrideValue).match(String(value)) !== null;
-    case 'not_regex':
-      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null;
-    case 'gt':
-    case 'gte':
-    case 'lt':
-    case 'lte':
-      {
-        // :TRICKY: We adjust comparison based on the override value passed in,
-        // to make sure we handle both numeric and string comparisons appropriately.
-        let parsedValue = typeof value === 'number' ? value : null;
-        if (typeof value === 'string') {
-          try {
-            parsedValue = parseFloat(value);
-          } catch (err) {
-            // pass
-          }
-        }
-        if (parsedValue != null && overrideValue != null) {
-          // check both null and undefined
-          if (typeof overrideValue === 'string') {
-            return compare(overrideValue, String(value), operator);
-          } else {
-            return compare(overrideValue, parsedValue, operator);
-          }
-        } else {
-          return compare(String(overrideValue), String(value), operator);
-        }
-      }
-    case 'is_date_after':
-    case 'is_date_before':
-      {
-        // Boolean values should never be used with date operations
-        if (typeof value === 'boolean') {
-          throw new InconclusiveMatchError(`Date operations cannot be performed on boolean values`);
-        }
-        let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
-        if (parsedDate == null) {
-          parsedDate = convertToDateTime(value);
-        }
-        if (parsedDate == null) {
-          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 matchCohort(property, propertyValues, cohortProperties, debugMode = false) {
-  const cohortId = String(property.value);
-  if (!(cohortId in cohortProperties)) {
-    throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
-  }
-  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 || properties.length === 0) {
-    // empty groups are no-ops, always match
-    return true;
-  }
-  let errorMatchingLocally = false;
-  if ('values' in properties[0]) {
-    // a nested property group
-    for (const prop of properties) {
-      try {
-        const matches = matchPropertyGroup(prop, propertyValues, cohortProperties, debugMode);
-        if (propertyGroupType === 'AND') {
-          if (!matches) {
-            return false;
-          }
-        } else {
-          // OR group
-          if (matches) {
-            return true;
-          }
-        }
-      } catch (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");
-    }
-    // if we get here, all matched in AND case, or none matched in OR case
-    return propertyGroupType === 'AND';
-  } else {
-    for (const prop of properties) {
-      try {
-        let matches;
-        if (prop.type === 'cohort') {
-          matches = matchCohort(prop, propertyValues, cohortProperties, debugMode);
-        } else if (prop.type === 'flag') {
-          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 (propertyGroupType === 'AND') {
-          // if negated property, do the inverse
-          if (!matches && !negation) {
-            return false;
-          }
-          if (matches && negation) {
-            return false;
-          }
-        } else {
-          // OR group
-          if (matches && !negation) {
-            return true;
-          }
-          if (!matches && negation) {
-            return true;
-          }
-        }
-      } catch (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");
-    }
-    // if we get here, all matched in AND case, or none matched in OR case
-    return propertyGroupType === 'AND';
-  }
-}
-function isValidRegex(regex) {
-  try {
-    new RegExp(regex);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-function convertToDateTime(value) {
-  if (value instanceof Date) {
-    return value;
-  } else if (typeof value === 'string' || typeof value === 'number') {
-    const date = new Date(value);
-    if (!isNaN(date.valueOf())) {
-      return date;
-    }
-    throw new InconclusiveMatchError(`${value} is in an invalid date format`);
-  } else {
-    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(new Date().toISOString());
-  if (match) {
-    if (!match.groups) {
-      return null;
-    }
-    const number = parseInt(match.groups['number']);
-    if (number >= 10000) {
-      // Guard against overflow, disallow numbers greater than 10_000
-      return null;
-    }
-    const interval = match.groups['interval'];
-    if (interval == 'h') {
-      parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
-    } else if (interval == 'd') {
-      parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
-    } else if (interval == 'w') {
-      parsedDt.setUTCDate(parsedDt.getUTCDate() - number * 7);
-    } else if (interval == 'm') {
-      parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
-    } else if (interval == 'y') {
-      parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
-    } else {
-      return null;
-    }
-    return parsedDt;
-  } else {
-    return null;
-  }
-}
-
-class PostHogMemoryStorage {
-  constructor() {
-    this._memoryStorage = {};
-  }
-  getProperty(key) {
-    return this._memoryStorage[key];
-  }
-  setProperty(key, value) {
-    this._memoryStorage[key] = value !== null ? value : undefined;
-  }
-}
-
-const _createLogger = (prefix, logMsgIfDebug) => {
-  const logger = {
-    _log: (level, ...args) => {
-      logMsgIfDebug(() => {
-        const consoleLog = console[level];
-        consoleLog(prefix, ...args);
-      });
-    },
-    info: (...args) => {
-      logger._log('log', ...args);
-    },
-    warn: (...args) => {
-      logger._log('warn', ...args);
-    },
-    error: (...args) => {
-      logger._log('error', ...args);
-    },
-    critical: (...args) => {
-      // Critical errors are always logged to the console
-      // eslint-disable-next-line no-console
-      console.error(prefix, ...args);
-    },
-    uninitializedWarning: methodName => {
-      logger.error(`You must initialize PostHog before calling ${methodName}`);
-    },
-    createLogger: additionalPrefix => _createLogger(`${prefix} ${additionalPrefix}`, logMsgIfDebug)
-  };
-  return logger;
-};
-const createLogger = logMsgIfDebug => _createLogger('[PostHog.js]', logMsgIfDebug);
-
-// Standard local evaluation rate limit is 600 per minute (10 per second),
-// so the fastest a poller should ever be set is 100ms.
-const MINIMUM_POLLING_INTERVAL = 100;
-const THIRTY_SECONDS = 30 * 1000;
-const MAX_CACHE_SIZE = 50 * 1000;
-// The actual exported Nodejs API.
-class PostHogBackendClient extends core.PostHogCoreStateless {
-  /**
-   * Initialize a new PostHog client instance.
-   *
-   * @example
-   * ```ts
-   * // Basic initialization
-   * const client = new PostHogBackendClient(
-   *   'your-api-key',
-   *   { host: 'https://app.posthog.com' }
-   * )
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With personal API key
-   * const client = new PostHogBackendClient(
-   *   'your-api-key',
-   *   {
-   *     host: 'https://app.posthog.com',
-   *     personalApiKey: 'your-personal-api-key'
-   *   }
-   * )
-   * ```
-   *
-   * {@label Initialization}
-   *
-   * @param apiKey - Your PostHog project API key
-   * @param options - Configuration options for the client
-   */
-  constructor(apiKey, options = {}) {
-    super(apiKey, options);
-    this._memoryStorage = new PostHogMemoryStorage();
-    this.options = options;
-    this.logger = createLogger(this.logMsgIfDebug.bind(this));
-    this.options.featureFlagsPollingInterval = typeof options.featureFlagsPollingInterval === 'number' ? 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.');
-      }
-      // Only start the poller if local evaluation is enabled (defaults to true for backward compatibility)
-      const shouldEnableLocalEvaluation = options.enableLocalEvaluation !== false;
-      if (shouldEnableLocalEvaluation) {
-        this.featureFlagsPoller = new FeatureFlagsPoller({
-          pollingInterval: this.options.featureFlagsPollingInterval,
-          personalApiKey: options.personalApiKey,
-          projectApiKey: apiKey,
-          timeout: options.requestTimeout ?? 10000,
-          // 10 seconds
-          host: this.host,
-          fetch: options.fetch,
-          onError: err => {
-            this._events.emit('error', err);
-          },
-          onLoad: count => {
-            this._events.emit('localEvaluationFlagsLoaded', count);
-          },
-          customHeaders: this.getCustomHeaders()
-        });
-      }
-    }
-    this.errorTracking = new ErrorTracking(this, options, this.logger);
-    this.distinctIdHasSentFlagCalls = {};
-    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
-  }
-  /**
-   * Get a persisted property value from memory storage.
-   *
-   * @example
-   * ```ts
-   * // Get user ID
-   * const userId = client.getPersistedProperty('userId')
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Get session ID
-   * const sessionId = client.getPersistedProperty('sessionId')
-   * ```
-   *
-   * {@label Initialization}
-   *
-   * @param key - The property key to retrieve
-   * @returns The stored property value or undefined if not found
-   */
-  getPersistedProperty(key) {
-    return this._memoryStorage.getProperty(key);
-  }
-  /**
-   * Set a persisted property value in memory storage.
-   *
-   * @example
-   * ```ts
-   * // Set user ID
-   * client.setPersistedProperty('userId', 'user_123')
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Set session ID
-   * client.setPersistedProperty('sessionId', 'session_456')
-   * ```
-   *
-   * {@label Initialization}
-   *
-   * @param key - The property key to set
-   * @param value - The value to store (null to remove)
-   */
-  setPersistedProperty(key, value) {
-    return this._memoryStorage.setProperty(key, value);
-  }
-  /**
-   * Make an HTTP request using the configured fetch function or default fetch.
-   *
-   * @example
-   * ```ts
-   * // POST request
-   * const response = await client.fetch('/api/endpoint', {
-   *   method: 'POST',
-   *   headers: { 'Content-Type': 'application/json' },
-   *   body: JSON.stringify(data)
-   * })
-   * ```
-   *
-   * @internal
-   *
-   * {@label Initialization}
-   *
-   * @param url - The URL to fetch
-   * @param options - Fetch options
-   * @returns Promise resolving to the fetch response
-   */
-  fetch(url, options) {
-    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
-  }
-  /**
-   * Get the library version from package.json.
-   *
-   * @example
-   * ```ts
-   * // Get version
-   * const version = client.getLibraryVersion()
-   * console.log(`Using PostHog SDK version: ${version}`)
-   * ```
-   *
-   * {@label Initialization}
-   *
-   * @returns The current library version string
-   */
-  getLibraryVersion() {
-    return version;
-  }
-  /**
-   * Get the custom user agent string for this client.
-   *
-   * @example
-   * ```ts
-   * // Get user agent
-   * const userAgent = client.getCustomUserAgent()
-   * // Returns: "posthog-node/5.7.0"
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @returns The formatted user agent string
-   */
-  getCustomUserAgent() {
-    return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
-  }
-  /**
-   * Enable the PostHog client (opt-in).
-   *
-   * @example
-   * ```ts
-   * // Enable client
-   * await client.enable()
-   * // Client is now enabled and will capture events
-   * ```
-   *
-   * {@label Privacy}
-   *
-   * @returns Promise that resolves when the client is enabled
-   */
-  enable() {
-    return super.optIn();
-  }
-  /**
-   * Disable the PostHog client (opt-out).
-   *
-   * @example
-   * ```ts
-   * // Disable client
-   * await client.disable()
-   * // Client is now disabled and will not capture events
-   * ```
-   *
-   * {@label Privacy}
-   *
-   * @returns Promise that resolves when the client is disabled
-   */
-  disable() {
-    return super.optOut();
-  }
-  /**
-   * Enable or disable debug logging.
-   *
-   * @example
-   * ```ts
-   * // Enable debug logging
-   * client.debug(true)
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Disable debug logging
-   * client.debug(false)
-   * ```
-   *
-   * {@label Initialization}
-   *
-   * @param enabled - Whether to enable debug logging
-   */
-  debug(enabled = true) {
-    super.debug(enabled);
-    this.featureFlagsPoller?.debug(enabled);
-  }
-  /**
-   * Capture an event manually.
-   *
-   * @example
-   * ```ts
-   * // Basic capture
-   * client.capture({
-   *   distinctId: 'user_123',
-   *   event: 'button_clicked',
-   *   properties: { button_color: 'red' }
-   * })
-   * ```
-   *
-   * {@label Capture}
-   *
-   * @param props - The event properties
-   * @returns void
-   */
-  capture(props) {
-    if (typeof props === 'string') {
-      this.logMsgIfDebug(() => console.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
-    }) => {
-      return super.captureStateless(distinctId, event, properties, {
-        timestamp: options.timestamp,
-        disableGeoip: options.disableGeoip,
-        uuid: options.uuid
-      });
-    }).catch(err => {
-      if (err) {
-        console.error(err);
-      }
-    }));
-  }
-  /**
-   * Capture an event immediately (synchronously).
-   *
-   * @example
-   * ```ts
-   * // Basic immediate capture
-   * await client.captureImmediate({
-   *   distinctId: 'user_123',
-   *   event: 'button_clicked',
-   *   properties: { button_color: 'red' }
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With feature flags
-   * await client.captureImmediate({
-   *   distinctId: 'user_123',
-   *   event: 'user_action',
-   *   sendFeatureFlags: true
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With custom feature flags options
-   * await client.captureImmediate({
-   *   distinctId: 'user_123',
-   *   event: 'user_action',
-   *   sendFeatureFlags: {
-   *     onlyEvaluateLocally: true,
-   *     personProperties: { plan: 'premium' },
-   *     groupProperties: { org: { tier: 'enterprise' } }
-   *     flagKeys: ['flag1', 'flag2']
-   *   }
-   * })
-   * ```
-   *
-   * {@label Capture}
-   *
-   * @param props - The event properties
-   * @returns Promise that resolves when the event is captured
-   */
-  async captureImmediate(props) {
-    if (typeof props === 'string') {
-      this.logMsgIfDebug(() => console.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
-    }) => {
-      return super.captureStatelessImmediate(distinctId, event, properties, {
-        timestamp: options.timestamp,
-        disableGeoip: options.disableGeoip,
-        uuid: options.uuid
-      });
-    }).catch(err => {
-      if (err) {
-        console.error(err);
-      }
-    }));
-  }
-  /**
-   * Identify a user and set their properties.
-   *
-   * @example
-   * ```ts
-   * // Basic identify with properties
-   * client.identify({
-   *   distinctId: 'user_123',
-   *   properties: {
-   *     name: 'John Doe',
-   *     email: 'john@example.com',
-   *     plan: 'premium'
-   *   }
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Using $set and $set_once
-   * client.identify({
-   *   distinctId: 'user_123',
-   *   properties: {
-   *     $set: { name: 'John Doe', email: 'john@example.com' },
-   *     $set_once: { first_login: new Date().toISOString() }
-   *   }
-   * })
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @param data - The identify data containing distinctId and properties
-   */
-  identify({
-    distinctId,
-    properties,
-    disableGeoip
-  }) {
-    // Catch properties passed as $set and move them to the top level
-    // promote $set and $set_once to top level
-    const userPropsOnce = properties?.$set_once;
-    delete properties?.$set_once;
-    // if no $set is provided we assume all properties are $set
-    const userProps = properties?.$set || properties;
-    super.identifyStateless(distinctId, {
-      $set: userProps,
-      $set_once: userPropsOnce
-    }, {
-      disableGeoip
-    });
-  }
-  /**
-   * Identify a user and set their properties immediately (synchronously).
-   *
-   * @example
-   * ```ts
-   * // Basic immediate identify
-   * await client.identifyImmediate({
-   *   distinctId: 'user_123',
-   *   properties: {
-   *     name: 'John Doe',
-   *     email: 'john@example.com'
-   *   }
-   * })
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @param data - The identify data containing distinctId and properties
-   * @returns Promise that resolves when the identify is processed
-   */
-  async identifyImmediate({
-    distinctId,
-    properties,
-    disableGeoip
-  }) {
-    // promote $set and $set_once to top level
-    const userPropsOnce = properties?.$set_once;
-    delete properties?.$set_once;
-    // if no $set is provided we assume all properties are $set
-    const userProps = properties?.$set || properties;
-    await super.identifyStatelessImmediate(distinctId, {
-      $set: userProps,
-      $set_once: userPropsOnce
-    }, {
-      disableGeoip
-    });
-  }
-  /**
-   * Create an alias to link two distinct IDs together.
-   *
-   * @example
-   * ```ts
-   * // Link an anonymous user to an identified user
-   * client.alias({
-   *   distinctId: 'anonymous_123',
-   *   alias: 'user_456'
-   * })
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @param data - The alias data containing distinctId and alias
-   */
-  alias(data) {
-    super.aliasStateless(data.alias, data.distinctId, undefined, {
-      disableGeoip: data.disableGeoip
-    });
-  }
-  /**
-   * Create an alias to link two distinct IDs together immediately (synchronously).
-   *
-   * @example
-   * ```ts
-   * // Link an anonymous user to an identified user immediately
-   * await client.aliasImmediate({
-   *   distinctId: 'anonymous_123',
-   *   alias: 'user_456'
-   * })
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @param data - The alias data containing distinctId and alias
-   * @returns Promise that resolves when the alias is processed
-   */
-  async aliasImmediate(data) {
-    await super.aliasStatelessImmediate(data.alias, data.distinctId, undefined, {
-      disableGeoip: data.disableGeoip
-    });
-  }
-  /**
-   * Check if local evaluation of feature flags is ready.
-   *
-   * @example
-   * ```ts
-   * // Check if ready
-   * if (client.isLocalEvaluationReady()) {
-   *   // Local evaluation is ready, can evaluate flags locally
-   *   const flag = await client.getFeatureFlag('flag-key', 'user_123')
-   * } else {
-   *   // Local evaluation not ready, will use remote evaluation
-   *   const flag = await client.getFeatureFlag('flag-key', 'user_123')
-   * }
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @returns true if local evaluation is ready, false otherwise
-   */
-  isLocalEvaluationReady() {
-    return this.featureFlagsPoller?.isLocalEvaluationReady() ?? false;
-  }
-  /**
-   * Wait for local evaluation of feature flags to be ready.
-   *
-   * @example
-   * ```ts
-   * // Wait for local evaluation
-   * const isReady = await client.waitForLocalEvaluationReady()
-   * if (isReady) {
-   *   console.log('Local evaluation is ready')
-   * } else {
-   *   console.log('Local evaluation timed out')
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Wait with custom timeout
-   * const isReady = await client.waitForLocalEvaluationReady(10000) // 10 seconds
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param timeoutMs - Timeout in milliseconds (default: 30000)
-   * @returns Promise that resolves to true if ready, false if timed out
-   */
-  async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
-    if (this.isLocalEvaluationReady()) {
-      return true;
-    }
-    if (this.featureFlagsPoller === undefined) {
-      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);
-      });
-    });
-  }
-  /**
-   * Get the value of a feature flag for a specific user.
-   *
-   * @example
-   * ```ts
-   * // Basic feature flag check
-   * const flagValue = await client.getFeatureFlag('new-feature', 'user_123')
-   * if (flagValue === 'variant-a') {
-   *   // Show variant A
-   * } else if (flagValue === 'variant-b') {
-   *   // Show variant B
-   * } else {
-   *   // Flag is disabled or not found
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With groups and properties
-   * const flagValue = await client.getFeatureFlag('org-feature', 'user_123', {
-   *   groups: { organization: 'acme-corp' },
-   *   personProperties: { plan: 'enterprise' },
-   *   groupProperties: { organization: { tier: 'premium' } }
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Only evaluate locally
-   * const flagValue = await client.getFeatureFlag('local-flag', 'user_123', {
-   *   onlyEvaluateLocally: true
-   * })
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param key - The feature flag key
-   * @param distinctId - The user's distinct ID
-   * @param options - Optional configuration for flag evaluation
-   * @returns Promise that resolves to the flag value or undefined
-   */
-  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;
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
-    }
-    if (sendFeatureFlagEvents == undefined) {
-      sendFeatureFlagEvents = this.options.sendFeatureFlagEvent ?? true;
-    }
-    let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
-    const flagWasLocallyEvaluated = response !== undefined;
-    let requestId = undefined;
-    let flagDetail = undefined;
-    if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
-      const remoteResponse = await super.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-      if (remoteResponse === undefined) {
-        return undefined;
-      }
-      flagDetail = remoteResponse.response;
-      response = core.getFeatureFlagValue(flagDetail);
-      requestId = remoteResponse?.requestId;
-    }
-    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
-        },
-        groups,
-        disableGeoip
-      });
-    }
-    return response;
-  }
-  /**
-   * Get the payload for a feature flag.
-   *
-   * @example
-   * ```ts
-   * // Get payload for a feature flag
-   * const payload = await client.getFeatureFlagPayload('flag-key', 'user_123')
-   * if (payload) {
-   *   console.log('Flag payload:', payload)
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Get payload with specific match value
-   * const payload = await client.getFeatureFlagPayload('flag-key', 'user_123', 'variant-a')
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With groups and properties
-   * const payload = await client.getFeatureFlagPayload('org-flag', 'user_123', undefined, {
-   *   groups: { organization: 'acme-corp' },
-   *   personProperties: { plan: 'enterprise' }
-   * })
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param key - The feature flag key
-   * @param distinctId - The user's distinct ID
-   * @param matchValue - Optional match value to get payload for
-   * @param options - Optional configuration for flag evaluation
-   * @returns Promise that resolves to the flag payload or undefined
-   */
-  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 = undefined;
-    const localEvaluationEnabled = this.featureFlagsPoller !== undefined;
-    if (localEvaluationEnabled) {
-      // Ensure flags are loaded before checking for the specific flag
-      await this.featureFlagsPoller?.loadFeatureFlags();
-      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
-      if (flag) {
-        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
-        if (result) {
-          matchValue = result.value;
-          response = result.payload;
-        }
-      }
-    }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
-    }
-    const payloadWasLocallyEvaluated = response !== undefined;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
-      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-    }
-    return response;
-  }
-  /**
-   * Get the remote config payload for a feature flag.
-   *
-   * @example
-   * ```ts
-   * // Get remote config payload
-   * const payload = await client.getRemoteConfigPayload('flag-key')
-   * if (payload) {
-   *   console.log('Remote config payload:', payload)
-   * }
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param flagKey - The feature flag key
-   * @returns Promise that resolves to the remote config payload or undefined
-   * @throws Error if personal API key is not provided
-   */
-  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 undefined;
-    }
-    const parsed = await response.json();
-    // The payload from the endpoint is stored as a JSON encoded string. So when we return
-    // it, it's effectively double encoded. As far as we know, we should never get single-encoded
-    // JSON, but we'll be defensive here just in case.
-    if (typeof parsed === 'string') {
-      try {
-        // If the parsed value is a string, try parsing it again to handle double-encoded JSON
-        return JSON.parse(parsed);
-      } catch (e) {
-        // If second parse fails, return the string as is
-        return parsed;
-      }
-    }
-    return parsed;
-  }
-  /**
-   * Check if a feature flag is enabled for a specific user.
-   *
-   * @example
-   * ```ts
-   * // Basic feature flag check
-   * const isEnabled = await client.isFeatureEnabled('new-feature', 'user_123')
-   * if (isEnabled) {
-   *   // Feature is enabled
-   *   console.log('New feature is active')
-   * } else {
-   *   // Feature is disabled
-   *   console.log('New feature is not active')
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With groups and properties
-   * const isEnabled = await client.isFeatureEnabled('org-feature', 'user_123', {
-   *   groups: { organization: 'acme-corp' },
-   *   personProperties: { plan: 'enterprise' }
-   * })
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param key - The feature flag key
-   * @param distinctId - The user's distinct ID
-   * @param options - Optional configuration for flag evaluation
-   * @returns Promise that resolves to true if enabled, false if disabled, undefined if not found
-   */
-  async isFeatureEnabled(key, distinctId, options) {
-    const feat = await this.getFeatureFlag(key, distinctId, options);
-    if (feat === undefined) {
-      return undefined;
-    }
-    return !!feat || false;
-  }
-  /**
-   * Get all feature flag values for a specific user.
-   *
-   * @example
-   * ```ts
-   * // Get all flags for a user
-   * const allFlags = await client.getAllFlags('user_123')
-   * console.log('User flags:', allFlags)
-   * // Output: { 'flag-1': 'variant-a', 'flag-2': false, 'flag-3': 'variant-b' }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With specific flag keys
-   * const specificFlags = await client.getAllFlags('user_123', {
-   *   flagKeys: ['flag-1', 'flag-2']
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With groups and properties
-   * const orgFlags = await client.getAllFlags('user_123', {
-   *   groups: { organization: 'acme-corp' },
-   *   personProperties: { plan: 'enterprise' }
-   * })
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param distinctId - The user's distinct ID
-   * @param options - Optional configuration for flag evaluation
-   * @returns Promise that resolves to a record of flag keys and their values
-   */
-  async getAllFlags(distinctId, options) {
-    const response = await this.getAllFlagsAndPayloads(distinctId, options);
-    return response.featureFlags || {};
-  }
-  /**
-   * Get all feature flag values and payloads for a specific user.
-   *
-   * @example
-   * ```ts
-   * // Get all flags and payloads for a user
-   * const result = await client.getAllFlagsAndPayloads('user_123')
-   * console.log('Flags:', result.featureFlags)
-   * console.log('Payloads:', result.featureFlagPayloads)
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With specific flag keys
-   * const result = await client.getAllFlagsAndPayloads('user_123', {
-   *   flagKeys: ['flag-1', 'flag-2']
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Only evaluate locally
-   * const result = await client.getAllFlagsAndPayloads('user_123', {
-   *   onlyEvaluateLocally: true
-   * })
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @param distinctId - The user's distinct ID
-   * @param options - Optional configuration for flag evaluation
-   * @returns Promise that resolves to flags and payloads
-   */
-  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;
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      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
-    };
-  }
-  /**
-   * Create or update a group and its properties.
-   *
-   * @example
-   * ```ts
-   * // Create a company group
-   * client.groupIdentify({
-   *   groupType: 'company',
-   *   groupKey: 'acme-corp',
-   *   properties: {
-   *     name: 'Acme Corporation',
-   *     industry: 'Technology',
-   *     employee_count: 500
-   *   },
-   *   distinctId: 'user_123'
-   * })
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Update organization properties
-   * client.groupIdentify({
-   *   groupType: 'organization',
-   *   groupKey: 'org-456',
-   *   properties: {
-   *     plan: 'enterprise',
-   *     region: 'US-West'
-   *   }
-   * })
-   * ```
-   *
-   * {@label Identification}
-   *
-   * @param data - The group identify data
-   */
-  groupIdentify({
-    groupType,
-    groupKey,
-    properties,
-    distinctId,
-    disableGeoip
-  }) {
-    super.groupIdentifyStateless(groupType, groupKey, properties, {
-      disableGeoip
-    }, distinctId);
-  }
-  /**
-   * Reload feature flag definitions from the server for local evaluation.
-   *
-   * @example
-   * ```ts
-   * // Force reload of feature flags
-   * await client.reloadFeatureFlags()
-   * console.log('Feature flags reloaded')
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Reload before checking a specific flag
-   * await client.reloadFeatureFlags()
-   * const flag = await client.getFeatureFlag('flag-key', 'user_123')
-   * ```
-   *
-   * {@label Feature flags}
-   *
-   * @returns Promise that resolves when flags are reloaded
-   */
-  async reloadFeatureFlags() {
-    await this.featureFlagsPoller?.loadFeatureFlags(true);
-  }
-  /**
-   * Shutdown the PostHog client gracefully.
-   *
-   * @example
-   * ```ts
-   * // Shutdown with default timeout
-   * await client._shutdown()
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Shutdown with custom timeout
-   * await client._shutdown(5000) // 5 seconds
-   * ```
-   *
-   * {@label Shutdown}
-   *
-   * @param shutdownTimeoutMs - Timeout in milliseconds for shutdown
-   * @returns Promise that resolves when shutdown is complete
-   */
-  async _shutdown(shutdownTimeoutMs) {
-    this.featureFlagsPoller?.stopPoller();
-    this.errorTracking.shutdown();
-    return super._shutdown(shutdownTimeoutMs);
-  }
-  async _requestRemoteConfigPayload(flagKey) {
-    if (!this.options.personalApiKey) {
-      return undefined;
-    }
-    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 && typeof this.options.requestTimeout === 'number') {
-      const controller = new AbortController();
-      abortTimeout = core.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 undefined;
-    } 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 the value is a plain object and the key exists in groups, treat it as group properties
-      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 {
-        // Otherwise treat as person property
-        personProperties[String(key)] = String(value);
-      }
-    }
-    return {
-      personProperties,
-      groupProperties
-    };
-  }
-  async getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions) {
-    // Use properties directly from options if they exist
-    const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
-    const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
-    const flagKeys = sendFeatureFlagsOptions?.flagKeys;
-    // Check if we should only evaluate locally
-    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
-    // If onlyEvaluateLocally is true, only use local evaluation
-    if (onlyEvaluateLocally) {
-      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
-        });
-      } else {
-        // If onlyEvaluateLocally is true but we don't have local flags, return empty
-        return {};
-      }
-    }
-    // Prefer local evaluation if available (default behavior; I'd rather not penalize users who haven't updated to the new API but still want to use local evaluation)
-    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
-      });
-    }
-    // Fall back to remote evaluation if local evaluation is not available
-    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
-    };
-  }
-  /**
-   * Capture an error exception as an event.
-   *
-   * @example
-   * ```ts
-   * // Capture an error with user ID
-   * try {
-   *   // Some risky operation
-   *   riskyOperation()
-   * } catch (error) {
-   *   client.captureException(error, 'user_123')
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Capture with additional properties
-   * try {
-   *   apiCall()
-   * } catch (error) {
-   *   client.captureException(error, 'user_123', {
-   *     endpoint: '/api/users',
-   *     method: 'POST',
-   *     status_code: 500
-   *   })
-   * }
-   * ```
-   *
-   * {@label Error tracking}
-   *
-   * @param error - The error to capture
-   * @param distinctId - Optional user distinct ID
-   * @param additionalProperties - Optional additional properties to include
-   */
-  captureException(error, distinctId, additionalProperties) {
-    const syntheticException = new Error('PostHog syntheticException');
-    this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
-      syntheticException
-    }, distinctId, additionalProperties).then(msg => this.capture(msg)));
-  }
-  /**
-   * Capture an error exception as an event immediately (synchronously).
-   *
-   * @example
-   * ```ts
-   * // Capture an error immediately with user ID
-   * try {
-   *   // Some risky operation
-   *   riskyOperation()
-   * } catch (error) {
-   *   await client.captureExceptionImmediate(error, 'user_123')
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Capture with additional properties
-   * try {
-   *   apiCall()
-   * } catch (error) {
-   *   await client.captureExceptionImmediate(error, 'user_123', {
-   *     endpoint: '/api/users',
-   *     method: 'POST',
-   *     status_code: 500
-   *   })
-   * }
-   * ```
-   *
-   * {@label Error tracking}
-   *
-   * @param error - The error to capture
-   * @param distinctId - Optional user distinct ID
-   * @param additionalProperties - Optional additional properties to include
-   * @returns Promise that resolves when the error is captured
-   */
-  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;
-    // Run before_send if configured
-    const eventMessage = this._runBeforeSend({
-      distinctId,
-      event,
-      properties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    });
-    if (!eventMessage) {
-      return Promise.reject(null);
-    }
-    // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
-    const eventProperties = await Promise.resolve().then(async () => {
-      if (sendFeatureFlags) {
-        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
-        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
-        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
-      }
-      if (event === '$feature_flag_called') {
-        // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
-        return {};
-      }
-      return {};
-    }).then(flags => {
-      // Derive the relevant flag properties to add
-      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(() => {
-      // Something went wrong getting the flag info - we should capture the event anyways
-      return {};
-    }).then(additionalProperties => {
-      // No matter what - capture the event
-      const props = {
-        ...additionalProperties,
-        ...(eventMessage.properties || {}),
-        $groups: eventMessage.groups || groups
-      };
-      return props;
-    });
-    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.logMsgIfDebug(() => console.info(`Event '${eventMessage.event}' was rejected in beforeSend function`));
-        return null;
-      }
-      if (!result.properties || Object.keys(result.properties).length === 0) {
-        const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
-        this.logMsgIfDebug(() => console.warn(message));
-      }
-    }
-    return result;
-  }
-}
-
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-// This was originally forked from https://github.com/csnover/TraceKit, and was largely
-// re-written as part of raven - js.
-//
-// This code was later copied to the JavaScript mono - repo and further modified and
-// refactored over the years.
-// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this
-// software and associated documentation files(the 'Software'), to deal in the Software
-// without restriction, including without limitation the rights to use, copy, modify,
-// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies
-// or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
-// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
-const STACKTRACE_FRAME_LIMIT = 50;
-const UNKNOWN_FUNCTION = '?';
-/** Node Stack line parser */
-function node(getModule) {
-  const FILENAME_MATCH = /^\s*[-]{4,}$/;
-  const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
-  return line => {
-    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 = undefined;
-      }
-      if (method) {
-        typeName = object;
-        methodName = method;
-      }
-      if (method === '<anonymous>') {
-        methodName = undefined;
-        functionName = undefined;
-      }
-      if (functionName === undefined) {
-        methodName = methodName || UNKNOWN_FUNCTION;
-        functionName = typeName ? `${typeName}.${methodName}` : methodName;
-      }
-      let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];
-      const isNative = lineMatch[5] === 'native';
-      // If it's a Windows path, trim the leading slash so that `/C:/foo` becomes `C:/foo`
-      if (filename?.match(/\/[A-Z]:/)) {
-        filename = filename.slice(1);
-      }
-      if (!filename && lineMatch[5] && !isNative) {
-        filename = lineMatch[5];
-      }
-      return {
-        filename: filename ? decodeURI(filename) : undefined,
-        module: undefined,
-        function: functionName,
-        lineno: _parseIntOrUndefined(lineMatch[3]),
-        colno: _parseIntOrUndefined(lineMatch[4]),
-        in_app: filenameIsInApp(filename || '', isNative),
-        platform: 'node:javascript'
-      };
-    }
-    if (line.match(FILENAME_MATCH)) {
-      return {
-        filename: line,
-        platform: 'node:javascript'
-      };
-    }
-    return undefined;
-  };
-}
-/**
- * Does this filename look like it's part of the app code?
- */
-function filenameIsInApp(filename, isNative = false) {
-  const isInternal = isNative || filename &&
-  // It's not internal if it's an absolute linux path
-  !filename.startsWith('/') &&
-  // It's not internal if it's an absolute windows path
-  !filename.match(/^[A-Z]:/) &&
-  // It's not internal if the path is starting with a dot
-  !filename.startsWith('.') &&
-  // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack
-  !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//); // Schema from: https://stackoverflow.com/a/3641782
-  // in_app is all that's not an internal Node function or a module within node_modules
-  // note that isNative appears to return true even for node core libraries
-  // see https://github.com/getsentry/raven-node/issues/176
-  return !isInternal && filename !== undefined && !filename.includes('node_modules/');
-}
-function _parseIntOrUndefined(input) {
-  return parseInt(input || '', 10) || undefined;
-}
-function nodeStackLineParser(getModule) {
-  return [90, node()];
-}
-function createStackParser(getModule) {
-  const parsers = [nodeStackLineParser()];
-  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);
-  return (stack, skipFirstLines = 0) => {
-    const frames = [];
-    const lines = stack.split('\n');
-    for (let i = skipFirstLines; i < lines.length; i++) {
-      const line = lines[i];
-      // Ignore lines over 1kb as they are unlikely to be stack frames.
-      if (line.length > 1024) {
-        continue;
-      }
-      // https://github.com/getsentry/sentry-javascript/issues/5459
-      // Remove webpack (error: *) wrappers
-      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
-      // https://github.com/getsentry/sentry-javascript/issues/7813
-      // Skip Error: lines
-      if (cleanedLine.match(/\S*Error: /)) {
-        continue;
-      }
-      for (const parser of sortedParsers) {
-        const frame = parser(cleanedLine);
-        if (frame) {
-          frames.push(frame);
-          break;
-        }
-      }
-      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
-        break;
-      }
-    }
-    return reverseAndStripFrames(frames);
-  };
-}
-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] || {};
-}
-
-ErrorTracking.stackParser = createStackParser();
-ErrorTracking.frameModifiers = [];
-class PostHog extends PostHogBackendClient {
-  getLibraryId() {
-    return 'posthog-edge';
-  }
-}
-
-exports.PostHog = PostHog;
-exports.PostHogSentryIntegration = PostHogSentryIntegration;
-exports.createEventProcessor = createEventProcessor;
-exports.sentryIntegration = sentryIntegration;
-exports.setupExpressErrorHandler = setupExpressErrorHandler;
-//# sourceMappingURL=index.cjs.map