posthog-node 4.2.0 → 4.2.2

package/lib/index.cjs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var rusha = require('rusha');
 
-var version = "4.2.0";
+var version = "4.2.2";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -22,6 +22,7 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["GroupProperties"] = "group_properties";
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
+    PostHogPersistedProperty["SessionReplay"] = "session_replay";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 
 function assert(truthyValue, message) {
@@ -966,7 +967,7 @@ class PostHogCoreStateless {
         this.maxBatchSize = Math.max(this.flushAt, options?.maxBatchSize ?? 100);
         this.maxQueueSize = Math.max(this.flushAt, options?.maxQueueSize ?? 1000);
         this.flushInterval = options?.flushInterval ?? 10000;
-        this.captureMode = options?.captureMode || 'form';
+        this.captureMode = options?.captureMode || 'json';
         // If enable is explicitly set to false we override the optout
         this.defaultOptIn = options?.defaultOptIn ?? true;
         this._retryOptions = {
@@ -983,11 +984,14 @@ class PostHogCoreStateless {
         this._initPromise = Promise.resolve();
         this._isInitialized = true;
     }
+    logMsgIfDebug(fn) {
+        if (this.isDebug) {
+            fn();
+        }
+    }
     wrap(fn) {
         if (this.disabled) {
-            if (this.isDebug) {
-                console.warn('[PostHog] The client is disabled');
-            }
+            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
             return;
         }
         if (this._isInitialized) {
@@ -1031,6 +1035,9 @@ class PostHogCoreStateless {
     get isDebug() {
         return !!this.removeDebugCallback;
     }
+    get isDisabled() {
+        return this.disabled;
+    }
     buildPayload(payload) {
         return {
             distinct_id: payload.distinct_id,
@@ -1227,7 +1234,7 @@ class PostHogCoreStateless {
             const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
             if (queue.length >= this.maxQueueSize) {
                 queue.shift();
-                console.info('Queue is full, the oldest event is dropped.');
+                this.logMsgIfDebug(() => console.info('Queue is full, the oldest event is dropped.'));
             }
             queue.push({ message });
             this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
@@ -1359,33 +1366,45 @@ class PostHogCoreStateless {
         }, { ...this._retryOptions, ...retryOptions });
     }
     async shutdown(shutdownTimeoutMs = 30000) {
+        // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
+        // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
         await this._initPromise;
+        let hasTimedOut = false;
         this.clearFlushTimer();
-        try {
-            await Promise.all(Object.values(this.pendingPromises));
-            const startTimeWithDelay = Date.now() + shutdownTimeoutMs;
-            while (true) {
-                const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-                if (queue.length === 0) {
-                    break;
-                }
-                // flush again to make sure we send all events, some of which might've been added
-                // while we were waiting for the pending promises to resolve
-                // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
-                await this.flush();
-                // If we've been waiting for more than the shutdownTimeoutMs, stop it
-                const now = Date.now();
-                if (startTimeWithDelay < now) {
-                    break;
+        const doShutdown = async () => {
+            try {
+                await Promise.all(Object.values(this.pendingPromises));
+                while (true) {
+                    const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                    if (queue.length === 0) {
+                        break;
+                    }
+                    // flush again to make sure we send all events, some of which might've been added
+                    // while we were waiting for the pending promises to resolve
+                    // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                    await this.flush();
+                    if (hasTimedOut) {
+                        break;
+                    }
                 }
             }
-        }
-        catch (e) {
-            if (!isPostHogFetchError(e)) {
-                throw e;
+            catch (e) {
+                if (!isPostHogFetchError(e)) {
+                    throw e;
+                }
+                this.logMsgIfDebug(() => console.error('Error while shutting down PostHog', e));
             }
-            console.error('Error while shutting down PostHog', e);
-        }
+        };
+        return Promise.race([
+            new Promise((_, reject) => {
+                safeSetTimeout(() => {
+                    this.logMsgIfDebug(() => console.error('Timed out while shutting down PostHog'));
+                    hasTimedOut = true;
+                    reject('Timeout while shutting down PostHog. Some events may not have been sent.');
+                }, shutdownTimeoutMs);
+            }),
+            doShutdown(),
+        ]);
     }
 }
 
@@ -1409,14 +1428,13 @@ class PostHogMemoryStorage {
  * This is currently solved by using the global fetch if available instead.
  * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
  */
-let _fetch = // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+let _fetch =
+// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
 // @ts-ignore
 typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
-
 if (!_fetch) {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const axios = require('axios');
-
   _fetch = async (url, options) => {
     const res = await axios.request({
       url,
@@ -1433,14 +1451,13 @@ if (!_fetch) {
       json: async () => res.data
     };
   };
-} // NOTE: We have to export this as default, even though we prefer named exports as we are relying on detecting "fetch" in the global scope
-
-
+}
+// NOTE: We have to export this as default, even though we prefer named exports as we are relying on detecting "fetch" in the global scope
 var fetch$1 = _fetch;
 
+// eslint-disable-next-line
 const LONG_SCALE = 0xfffffffffffffff;
 const NULL_VALUES_ALLOWED_OPERATORS = ['is_not'];
-
 class ClientError extends Error {
   constructor(message) {
     super();
@@ -1449,22 +1466,18 @@ class ClientError extends Error {
     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
+    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,
@@ -1486,81 +1499,69 @@ class FeatureFlagsPoller {
     this.timeout = timeout;
     this.projectApiKey = projectApiKey;
     this.host = host;
-    this.poller = undefined; // NOTE: as any is required here as the AbortSignal typing is slightly misaligned but works just fine
-
+    this.poller = undefined;
+    // NOTE: as any is required here as the AbortSignal typing is slightly misaligned but works just fine
     this.fetch = options.fetch || fetch$1;
     this.onError = options.onError;
     this.customHeaders = customHeaders;
     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;
     }
-
     for (const flag of this.featureFlags) {
       if (key === flag.key) {
         featureFlag = flag;
         break;
       }
     }
-
     if (featureFlag !== undefined) {
       try {
         response = this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
-
-        if (this.debugMode) {
-          console.debug(`Successfully computed flag locally: ${key} -> ${response}`);
-        }
+        this.logMsgIfDebug(() => console.debug(`Successfully computed flag locally: ${key} -> ${response}`));
       } catch (e) {
         if (e instanceof InconclusiveMatchError) {
-          if (this.debugMode) {
-            console.debug(`InconclusiveMatchError when computing flag locally: ${key}: ${e}`);
-          }
+          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 computeFeatureFlagPayloadLocally(key, matchValue) {
     await this.loadFeatureFlags();
     let response = undefined;
-
     if (!this.loadedSuccessfullyOnce) {
       return undefined;
     }
-
     if (typeof matchValue == 'boolean') {
       response = this.featureFlagsByKey?.[key]?.filters?.payloads?.[matchValue.toString()];
     } else if (typeof matchValue == 'string') {
       response = this.featureFlagsByKey?.[key]?.filters?.payloads?.[matchValue];
-    } // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
-
-
+    }
+    // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
     if (response === undefined || response === null) {
       return null;
     }
-
     try {
       return JSON.parse(response);
     } catch {
       return response;
     }
   }
-
   async getAllFlagsAndPayloads(distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
     await this.loadFeatureFlags();
     const response = {};
@@ -1571,7 +1572,6 @@ class FeatureFlagsPoller {
         const matchValue = this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties);
         response[flag.key] = matchValue;
         const matchPayload = await this.computeFeatureFlagPayloadLocally(flag.key, matchValue);
-
         if (matchPayload) {
           payloads[flag.key] = matchPayload;
         }
@@ -1579,7 +1579,6 @@ class FeatureFlagsPoller {
         if (e instanceof InconclusiveMatchError) ; else if (e instanceof Error) {
           this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
         }
-
         fallbackToDecide = true;
       }
     });
@@ -1589,56 +1588,41 @@ class FeatureFlagsPoller {
       fallbackToDecide
     };
   }
-
   computeFlagLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
     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) {
-        if (this.debugMode) {
-          console.warn(`[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${flag.key}`);
-        }
-
+        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)) {
-        if (this.debugMode) {
-          console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`);
-        }
-
+        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 this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties);
     } else {
       return this.matchFeatureFlagProperties(flag, distinctId, personProperties);
     }
   }
-
   matchFeatureFlagProperties(flag, distinctId, properties) {
     const flagFilters = flag.filters || {};
     const flagConditions = flagFilters.groups || [];
     let isInconclusive = false;
-    let result = undefined; // # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
+    let result = undefined;
+    // # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
     // # evaluated first, and the variant override is applied to the first matching condition.
-
     const sortedFlagConditions = [...flagConditions].sort((conditionA, conditionB) => {
       const AHasVariantOverride = !!conditionA.variant;
       const BHasVariantOverride = !!conditionB.variant;
-
       if (AHasVariantOverride && BHasVariantOverride) {
         return 0;
       } else if (AHasVariantOverride) {
@@ -1649,19 +1633,16 @@ class FeatureFlagsPoller {
         return 0;
       }
     });
-
     for (const condition of sortedFlagConditions) {
       try {
         if (this.isConditionMatch(flag, distinctId, condition, properties)) {
           const variantOverride = condition.variant;
           const flagVariants = flagFilters.multivariate?.variants || [];
-
           if (variantOverride && flagVariants.some(variant => variant.key === variantOverride)) {
             result = variantOverride;
           } else {
             result = this.getMatchingVariant(flag, distinctId) || true;
           }
-
           break;
         }
       } catch (e) {
@@ -1672,68 +1653,51 @@ class FeatureFlagsPoller {
         }
       }
     }
-
     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
-
-
+    }
+    // We can only return False when all conditions are False
     return false;
   }
-
   isConditionMatch(flag, distinctId, condition, properties) {
     const rolloutPercentage = condition.rollout_percentage;
-
     const warnFunction = msg => {
-      if (this.debugMode) {
-        console.warn(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 {
           matches = matchProperty(prop, properties, warnFunction);
         }
-
         if (!matches) {
           return false;
         }
       }
-
       if (rolloutPercentage == undefined) {
         return true;
       }
     }
-
     if (rolloutPercentage != undefined && _hash(flag.key, distinctId) > rolloutPercentage / 100.0) {
       return false;
     }
-
     return true;
   }
-
   getMatchingVariant(flag, distinctId) {
     const hashValue = _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;
@@ -1751,40 +1715,31 @@ class FeatureFlagsPoller {
     });
     return lookupTable;
   }
-
   async loadFeatureFlags(forceReload = false) {
     if (!this.loadedSuccessfullyOnce || forceReload) {
       await this._loadFeatureFlags();
     }
   }
-
   async _loadFeatureFlags() {
     if (this.poller) {
       clearTimeout(this.poller);
       this.poller = undefined;
     }
-
     this.poller = setTimeout(() => this._loadFeatureFlags(), this.pollingInterval);
-
     try {
       const res = await this._requestFeatureFlagDefinitions();
-
       if (res && res.status === 401) {
         throw new ClientError(`Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview`);
       }
-
       if (res && res.status !== 200) {
         // something else went wrong, or the server is down.
         // In this case, don't override existing flags
         return;
       }
-
       const responseJson = await res.json();
-
       if (!('flags' in responseJson)) {
         this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
       }
-
       this.featureFlags = responseJson.flags || [];
       this.featureFlagsByKey = this.featureFlags.reduce((acc, curr) => (acc[curr.key] = curr, acc), {});
       this.groupTypeMapping = responseJson.group_type_mapping || {};
@@ -1798,18 +1753,17 @@ class FeatureFlagsPoller {
       }
     }
   }
-
   async _requestFeatureFlagDefinitions() {
     const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
     const options = {
       method: 'GET',
-      headers: { ...this.customHeaders,
+      headers: {
+        ...this.customHeaders,
         'Content-Type': 'application/json',
         Authorization: `Bearer ${this.personalApiKey}`
       }
     };
     let abortTimeout = null;
-
     if (this.timeout && typeof this.timeout === 'number') {
       const controller = new AbortController();
       abortTimeout = safeSetTimeout(() => {
@@ -1817,62 +1771,50 @@ class FeatureFlagsPoller {
       }, 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.
+}
+// # 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
-
-
 function _hash(key, distinctId, salt = '') {
   // rusha is a fast sha1 implementation in pure javascript
   const sha1Hash = rusha.createHash();
   sha1Hash.update(`${key}.${distinctId}${salt}`);
   return parseInt(sha1Hash.digest('hex').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;
@@ -1886,29 +1828,21 @@ function matchProperty(property, propertyValues, warnFunction) {
       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':
@@ -1917,14 +1851,13 @@ function matchProperty(property, propertyValues, warnFunction) {
         // :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
+          } catch (err) {
+            // pass
           }
         }
-
         if (parsedValue != null && overrideValue != null) {
           // check both null and undefined
           if (typeof overrideValue === 'string') {
@@ -1936,66 +1869,50 @@ function matchProperty(property, propertyValues, warnFunction) {
           return compare(String(overrideValue), String(value), operator);
         }
       }
-
     case 'is_date_after':
     case 'is_date_before':
       {
         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;
@@ -2011,39 +1928,32 @@ function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, deb
           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
-
-
+    }
+    // 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 {
           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;
           }
@@ -2052,7 +1962,6 @@ function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, deb
           if (matches && !negation) {
             return true;
           }
-
           if (!matches && negation) {
             return true;
           }
@@ -2062,23 +1971,19 @@ function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, deb
           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
-
-
+    }
+    // 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);
@@ -2087,42 +1992,33 @@ function isValidRegex(regex) {
     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') {
@@ -2136,7 +2032,6 @@ function relativeDateParseForFeatureFlagMatching(value) {
     } else {
       return null;
     }
-
     return parsedDt;
   } else {
     return null;
@@ -2144,15 +2039,13 @@ function relativeDateParseForFeatureFlagMatching(value) {
 }
 
 const THIRTY_SECONDS = 30 * 1000;
-const MAX_CACHE_SIZE = 50 * 1000; // The actual exported Nodejs API.
-
+const MAX_CACHE_SIZE = 50 * 1000;
+// The actual exported Nodejs API.
 class PostHog extends PostHogCoreStateless {
   constructor(apiKey, options = {}) {
-    options.captureMode = options?.captureMode || 'json';
     super(apiKey, options);
     this._memoryStorage = new PostHogMemoryStorage();
     this.options = options;
-
     if (options.personalApiKey) {
       this.featureFlagsPoller = new FeatureFlagsPoller({
         pollingInterval: typeof options.featureFlagsPollingInterval === 'number' ? options.featureFlagsPollingInterval : THIRTY_SECONDS,
@@ -2167,48 +2060,37 @@ class PostHog extends PostHogCoreStateless {
         customHeaders: this.getCustomHeaders()
       });
     }
-
     this.distinctIdHasSentFlagCalls = {};
     this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
   }
-
   getPersistedProperty(key) {
     return this._memoryStorage.getProperty(key);
   }
-
   setPersistedProperty(key, value) {
     return this._memoryStorage.setProperty(key, value);
   }
-
   fetch(url, options) {
     return this.options.fetch ? this.options.fetch(url, options) : fetch$1(url, options);
   }
-
   getLibraryId() {
     return 'posthog-node';
   }
-
   getLibraryVersion() {
     return version;
   }
-
   getCustomUserAgent() {
     return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
   }
-
   enable() {
     return super.optIn();
   }
-
   disable() {
     return super.optOut();
   }
-
   debug(enabled = true) {
     super.debug(enabled);
     this.featureFlagsPoller?.debug(enabled);
   }
-
   capture({
     distinctId,
     event,
@@ -2226,65 +2108,55 @@ class PostHog extends PostHogCoreStateless {
         uuid
       });
     };
-
     const _getFlags = (distinctId, groups, disableGeoip) => {
       return super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip);
-    }; // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
-
-
+    };
+    // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
     const capturePromise = Promise.resolve().then(async () => {
       if (sendFeatureFlags) {
         // If we are sending feature flags, we need to make sure we have the latest flags
         // return await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)
         return await _getFlags(distinctId, groups, disableGeoip);
       }
-
       if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
         // Otherwise we may as well check for the flags locally and include them if there
         const groupsWithStringValues = {};
-
         for (const [key, value] of Object.entries(groups || {})) {
           groupsWithStringValues[key] = String(value);
         }
-
         return await this.getAllFlags(distinctId, {
           groups: groupsWithStringValues,
           disableGeoip,
           onlyEvaluateLocally: true
         });
       }
-
       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);
-
       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
-      _capture({ ...additionalProperties,
+      _capture({
+        ...additionalProperties,
         ...properties,
         $groups: groups
       });
     });
     this.addPendingPromise(capturePromise);
   }
-
   identify({
     distinctId,
     properties,
@@ -2298,13 +2170,11 @@ class PostHog extends PostHogCoreStateless {
       disableGeoip
     });
   }
-
   alias(data) {
     super.aliasStateless(data.alias, data.distinctId, undefined, {
       disableGeoip: data.disableGeoip
     });
   }
-
   async getFeatureFlag(key, distinctId, options) {
     const {
       groups,
@@ -2318,36 +2188,29 @@ class PostHog extends PostHogCoreStateless {
     } = options || {};
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties; // set defaults
-
+    groupProperties = adjustedProperties.allGroupProperties;
+    // set defaults
     if (onlyEvaluateLocally == undefined) {
       onlyEvaluateLocally = false;
     }
-
     if (sendFeatureFlagEvents == undefined) {
       sendFeatureFlagEvents = true;
     }
-
     let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
     const flagWasLocallyEvaluated = response !== undefined;
-
     if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
       response = await super.getFeatureFlagStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
     }
-
     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',
@@ -2361,10 +2224,8 @@ class PostHog extends PostHogCoreStateless {
         disableGeoip
       });
     }
-
     return response;
   }
-
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     const {
       groups,
@@ -2379,56 +2240,45 @@ class PostHog extends PostHogCoreStateless {
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
     groupProperties = adjustedProperties.allGroupProperties;
-    let response = undefined; // Try to get match value locally if not provided
-
+    let response = undefined;
+    // Try to get match value locally if not provided
     if (!matchValue) {
-      matchValue = await this.getFeatureFlag(key, distinctId, { ...options,
+      matchValue = await this.getFeatureFlag(key, distinctId, {
+        ...options,
         onlyEvaluateLocally: true
       });
     }
-
     if (matchValue) {
       response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
-    } // set defaults
-
-
+    }
+    // set defaults
     if (onlyEvaluateLocally == undefined) {
       onlyEvaluateLocally = false;
     }
-
     if (sendFeatureFlagEvents == undefined) {
       sendFeatureFlagEvents = true;
-    } // set defaults
-
-
+    }
+    // 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;
   }
-
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);
-
     if (feat === undefined) {
       return undefined;
     }
-
     return !!feat || false;
   }
-
   async getAllFlags(distinctId, options) {
     const response = await this.getAllFlagsAndPayloads(distinctId, options);
     return response.featureFlags;
   }
-
   async getAllFlagsAndPayloads(distinctId, options) {
     const {
       groups,
@@ -2441,39 +2291,36 @@ class PostHog extends PostHogCoreStateless {
     } = options || {};
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties; // set defaults
-
+    groupProperties = adjustedProperties.allGroupProperties;
+    // set defaults
     if (onlyEvaluateLocally == undefined) {
       onlyEvaluateLocally = false;
     }
-
     const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties);
     let featureFlags = {};
     let featureFlagPayloads = {};
     let fallbackToDecide = true;
-
     if (localEvaluationResult) {
       featureFlags = localEvaluationResult.response;
       featureFlagPayloads = localEvaluationResult.payloads;
       fallbackToDecide = localEvaluationResult.fallbackToDecide;
     }
-
     if (fallbackToDecide && !onlyEvaluateLocally) {
       const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
-      featureFlags = { ...featureFlags,
+      featureFlags = {
+        ...featureFlags,
         ...(remoteEvaluationResult.flags || {})
       };
-      featureFlagPayloads = { ...featureFlagPayloads,
+      featureFlagPayloads = {
+        ...featureFlagPayloads,
         ...(remoteEvaluationResult.payloads || {})
       };
     }
-
     return {
       featureFlags,
       featureFlagPayloads
     };
   }
-
   groupIdentify({
     groupType,
     groupKey,
@@ -2485,23 +2332,19 @@ class PostHog extends PostHogCoreStateless {
       disableGeoip
     }, distinctId);
   }
-
   async reloadFeatureFlags() {
     await this.featureFlagsPoller?.loadFeatureFlags(true);
   }
-
   async shutdown(shutdownTimeoutMs) {
     this.featureFlagsPoller?.stopPoller();
     return super.shutdown(shutdownTimeoutMs);
   }
-
   addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
     const allPersonProperties = {
       distinct_id: distinctId,
       ...(personProperties || {})
     };
     const allGroupProperties = {};
-
     if (groups) {
       for (const groupName of Object.keys(groups)) {
         allGroupProperties[groupName] = {
@@ -2510,13 +2353,11 @@ class PostHog extends PostHogCoreStateless {
         };
       }
     }
-
     return {
       allPersonProperties,
       allGroupProperties
     };
   }
-
 }
 
 /**
@@ -2547,26 +2388,21 @@ class PostHogSentryIntegration {
     this.name = 'posthog-node';
     this.posthogHost = posthog.options.host ?? 'https://us.i.posthog.com';
   }
-
   setupOnce(addGlobalEventProcessor, getCurrentHub) {
     addGlobalEventProcessor(event => {
       if (event.exception?.values === undefined || event.exception.values.length === 0) {
         return event;
       }
-
       if (!event.tags) {
         event.tags = {};
       }
-
-      const sentry = getCurrentHub(); // Get the PostHog user ID from a specific tag, which users can set on their Sentry scope as they need.
-
+      const sentry = getCurrentHub();
+      // 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;
       }
-
       event.tags['PostHog Person URL'] = new URL(`/person/${userId}`, this.posthogHost).toString();
       const properties = {
         // PostHog Exception Properties
@@ -2581,11 +2417,9 @@ class PostHogSentryIntegration {
         $sentry_tags: event.tags
       };
       const projectId = sentry.getClient()?.getDsn()?.projectId;
-
       if (this.organization !== undefined && projectId !== undefined && event.event_id !== undefined) {
         properties.$sentry_url = `${this.prefix ?? 'https://sentry.io/organizations'}/${this.organization}/issues/?project=${projectId}&query=${event.event_id}`;
       }
-
       this.posthog.capture({
         event: '$exception',
         distinctId: userId,
@@ -2594,7 +2428,6 @@ class PostHogSentryIntegration {
       return event;
     });
   }
-
 }
 PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';