@posthog/core 1.49.2 → 1.50.0

package/dist/utils/otlp-any-value.mjs

@@ -0,0 +1,166 @@
+import { isArray, isBoolean, isNull, isNullish, isUndefined } from "./type-utils.mjs";
+import { CIRCULAR_VALUE, FUNCTION_VALUE, MAX_JSON_SAFE_VALUE_DEPTH, MAX_JSON_SAFE_VALUE_ITEMS, MAX_JSON_SAFE_VALUE_NODES, TRUNCATED_VALUE, UNSERIALIZABLE_VALUE, sanitizeString } from "./json-utils.mjs";
+const INT64_RANGE_LIMIT = 9223372036854775808;
+const INT64_RANGE_LIMIT_DECIMAL = '9223372036854775808';
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+function newState() {
+    return {
+        ancestors: new WeakSet(),
+        remainingNodes: MAX_JSON_SAFE_VALUE_NODES
+    };
+}
+function toOtlpAnyValue(value, logger) {
+    try {
+        return encodeAnyValue(value, logger, newState(), 0);
+    } catch  {
+        return {
+            stringValue: UNSERIALIZABLE_VALUE
+        };
+    }
+}
+function toOtlpKeyValueList(attrs, logger) {
+    try {
+        return encodeKeyValueList(attrs, logger, newState(), 0);
+    } catch  {
+        return [];
+    }
+}
+function encodeBigInt(value, logger) {
+    const decimal = value.toString();
+    const limit = BigInt(INT64_RANGE_LIMIT_DECIMAL);
+    if (value >= limit || value < -limit) {
+        logger?.debug(`Attribute ${decimal} is outside the int64 range; encoding it as a string`);
+        return {
+            stringValue: decimal
+        };
+    }
+    return {
+        intValue: decimal
+    };
+}
+function encodeAnyValue(value, logger, state, depth) {
+    if (state.remainingNodes <= 0) return {
+        stringValue: TRUNCATED_VALUE
+    };
+    state.remainingNodes--;
+    if (isBoolean(value)) return {
+        boolValue: value
+    };
+    if ('bigint' == typeof value) return encodeBigInt(value, logger);
+    if ('number' == typeof value) {
+        if (!Number.isFinite(value)) return {
+            stringValue: String(value)
+        };
+        if (Number.isInteger(value)) {
+            if (Number.isSafeInteger(value)) return {
+                intValue: String(value)
+            };
+            if ('undefined' == typeof BigInt) return {
+                stringValue: String(value)
+            };
+            const decimal = BigInt(value).toString();
+            if (value >= INT64_RANGE_LIMIT || value < -INT64_RANGE_LIMIT) {
+                logger?.debug(`Attribute ${decimal} is outside the int64 range; encoding it as a string`);
+                return {
+                    stringValue: decimal
+                };
+            }
+            return {
+                intValue: decimal
+            };
+        }
+        return {
+            doubleValue: value
+        };
+    }
+    if ('string' == typeof value) return {
+        stringValue: sanitizeString(value)
+    };
+    if ('function' == typeof value) return {
+        stringValue: FUNCTION_VALUE
+    };
+    if ('symbol' == typeof value) return {
+        stringValue: String(value)
+    };
+    if ('object' == typeof value && null !== value) {
+        if (state.ancestors.has(value)) return {
+            stringValue: CIRCULAR_VALUE
+        };
+        if (depth >= MAX_JSON_SAFE_VALUE_DEPTH) return {
+            stringValue: TRUNCATED_VALUE
+        };
+        if (value instanceof Date) {
+            const time = value.getTime();
+            const iso = Number.isFinite(time) ? value.toISOString() : String(value);
+            return {
+                stringValue: 'string' == typeof iso ? sanitizeString(iso) : String(iso)
+            };
+        }
+        state.ancestors.add(value);
+        try {
+            try {
+                const toJSON = value.toJSON;
+                if ('function' == typeof toJSON) return encodeAnyValue(toJSON.call(value), logger, state, depth + 1);
+            } catch  {}
+            if (isArray(value)) return {
+                arrayValue: {
+                    values: encodeArrayValues(value, logger, state, depth + 1)
+                }
+            };
+            return {
+                kvlistValue: {
+                    values: encodeKeyValueList(value, logger, state, depth + 1)
+                }
+            };
+        } finally{
+            state.ancestors.delete(value);
+        }
+    }
+    return {
+        stringValue: sanitizeString(String(value))
+    };
+}
+function encodeArrayValues(values, logger, state, depth) {
+    const result = [];
+    const itemCount = Math.min(values.length, MAX_JSON_SAFE_VALUE_ITEMS);
+    let index = 0;
+    for(; index < itemCount && state.remainingNodes > 0; index++)try {
+        const element = index in values ? values[index] : void 0;
+        if (isNullish(element)) continue;
+        result.push(encodeAnyValue(element, logger, state, depth));
+    } catch  {
+        result.push({
+            stringValue: UNSERIALIZABLE_VALUE
+        });
+    }
+    if (values.length > index) result.push({
+        stringValue: TRUNCATED_VALUE
+    });
+    return result;
+}
+function encodeKeyValueList(attrs, logger, state, depth) {
+    const result = [];
+    for(const key in attrs)if (propertyIsEnumerable.call(attrs, key)) {
+        if (result.length >= MAX_JSON_SAFE_VALUE_ITEMS || state.remainingNodes <= 0) {
+            logger?.debug('Attributes truncated: the value exceeds the OTLP encoder budget');
+            break;
+        }
+        try {
+            const value = attrs[key];
+            if (isNull(value) || isUndefined(value)) continue;
+            result.push({
+                key: sanitizeString(key),
+                value: encodeAnyValue(value, logger, state, depth)
+            });
+        } catch  {
+            result.push({
+                key: sanitizeString(key),
+                value: {
+                    stringValue: UNSERIALIZABLE_VALUE
+                }
+            });
+        }
+    }
+    return result;
+}
+export { toOtlpAnyValue, toOtlpKeyValueList };

package/dist/utils/user-agent-utils.d.ts

@@ -8,10 +8,10 @@ export interface BrowserDetectionHints {
     brave?: boolean;
 }
 /**
- * Opt-in tweaks to UA-string detection. These change how existing traffic is
- * attributed, so the host SDK gates them (behind its `2026-05-30` config
- * defaults) rather than enabling them unconditionally — turning one on
- * reattributes browsers that were previously reported as something else.
+ * Opt-in tweaks to UA-string detection. Turning one on reattributes browsers
+ * that were previously reported as something else, so the host SDK gates
+ * shifts big enough to move users' metrics behind its `2026-05-30` config
+ * defaults. Smaller reattributions ship unconditionally in `detectBrowser`.
  */
 export interface BrowserDetectionOptions {
     detectGoogleSearchApp?: boolean;

package/dist/utils/user-agent-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-agent-utils.d.ts","sourceRoot":"","sources":["../../src/utils/user-agent-utils.ts"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAGpC,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AASD;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IAGtC,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAgCD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,MAAM,EAClB,QAAQ,MAAM,GAAG,SAAS,EAC1B,QAAQ,qBAAqB,EAC7B,UAAU,uBAAuB,KAChC,MA2FF,CAAA;AAmCD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,QAAQ,MAAM,GAAG,SAAS,EAC1B,QAAQ,qBAAqB,EAC7B,UAAU,uBAAuB,KAChC,MAAM,GAAG,IAmBX,CAAA;AA0FD,eAAO,MAAM,QAAQ,GAAa,YAAY,MAAM,KAAG,CAAC,MAAM,EAAE,MAAM,CAUrE,CAAA;AAED,eAAO,MAAM,YAAY,GAAa,YAAY,MAAM,KAAG,MAuD1D,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,YAAY,MAAM,EAClB,UAAU;IACR,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,KACA,MA4BF,CAAA"}
+{"version":3,"file":"user-agent-utils.d.ts","sourceRoot":"","sources":["../../src/utils/user-agent-utils.ts"],"names":[],"mappings":"AAsEA;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAGpC,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AASD;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IAGtC,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAgCD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,MAAM,EAClB,QAAQ,MAAM,GAAG,SAAS,EAC1B,QAAQ,qBAAqB,EAC7B,UAAU,uBAAuB,KAChC,MAkGF,CAAA;AAsCD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,QAAQ,MAAM,GAAG,SAAS,EAC1B,QAAQ,qBAAqB,EAC7B,UAAU,uBAAuB,KAChC,MAAM,GAAG,IAmBX,CAAA;AA0FD,eAAO,MAAM,QAAQ,GAAa,YAAY,MAAM,KAAG,CAAC,MAAM,EAAE,MAAM,CAUrE,CAAA;AAED,eAAO,MAAM,YAAY,GAAa,YAAY,MAAM,KAAG,MAuD1D,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,YAAY,MAAM,EAClB,UAAU;IACR,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,KACA,MA4BF,CAAA"}

package/dist/utils/user-agent-utils.js

@@ -78,9 +78,13 @@ const DUCKDUCKGO = 'DuckDuckGo';
 const PALE_MOON = 'Pale Moon';
 const WATERFOX = 'Waterfox';
 const BRAVE = 'Brave';
+const CLAUDE = 'Claude';
+const CODEX = 'Codex';
+const CHATGPT = 'ChatGPT';
 const GOOGLE_SEARCH_APP = 'Google Search App';
 const BROWSER_VERSION_REGEX_SUFFIX = '(\\d+(\\.\\d+)?)';
 const DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX);
+const AI_APP_VERSION_REGEX = new RegExp('(' + CLAUDE + '|' + CODEX + '|' + CHATGPT + ')\\/' + BROWSER_VERSION_REGEX_SUFFIX);
 function browserFromHints(hints) {
     if (hints?.brave) return BRAVE;
     return null;
@@ -122,6 +126,9 @@ const detectBrowser = function(user_agent, vendor, hints, options) {
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, 'YaBrowser/')) return YANDEX;
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, WHALE + '/')) return WHALE;
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, DUCKDUCKGO + '/') || (0, external_string_utils_js_namespaceObject.includes)(user_agent, 'Ddg/')) return DUCKDUCKGO;
+    else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, CLAUDE + '/')) return CLAUDE;
+    else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, CODEX + '/')) return CODEX;
+    else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, CHATGPT + '/')) return CHATGPT;
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, 'FBIOS')) return FACEBOOK + ' ' + MOBILE;
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, 'UCWEB') || (0, external_string_utils_js_namespaceObject.includes)(user_agent, 'UCBrowser')) return 'UC Browser';
     else if ((0, external_string_utils_js_namespaceObject.includes)(user_agent, 'CriOS')) return CHROME_IOS;
@@ -198,6 +205,15 @@ const versionRegexes = {
     [BRAVE]: [
         new RegExp(BRAVE + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)
     ],
+    [CLAUDE]: [
+        AI_APP_VERSION_REGEX
+    ],
+    [CODEX]: [
+        AI_APP_VERSION_REGEX
+    ],
+    [CHATGPT]: [
+        AI_APP_VERSION_REGEX
+    ],
     [DUCKDUCKGO]: [
         new RegExp('(DuckDuckGo|Ddg)\\/' + BROWSER_VERSION_REGEX_SUFFIX)
     ],

package/dist/utils/user-agent-utils.mjs

@@ -46,9 +46,13 @@ const DUCKDUCKGO = 'DuckDuckGo';
 const PALE_MOON = 'Pale Moon';
 const WATERFOX = 'Waterfox';
 const BRAVE = 'Brave';
+const CLAUDE = 'Claude';
+const CODEX = 'Codex';
+const CHATGPT = 'ChatGPT';
 const GOOGLE_SEARCH_APP = 'Google Search App';
 const BROWSER_VERSION_REGEX_SUFFIX = '(\\d+(\\.\\d+)?)';
 const DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX);
+const AI_APP_VERSION_REGEX = new RegExp('(' + CLAUDE + '|' + CODEX + '|' + CHATGPT + ')\\/' + BROWSER_VERSION_REGEX_SUFFIX);
 function browserFromHints(hints) {
     if (hints?.brave) return BRAVE;
     return null;
@@ -90,6 +94,9 @@ const detectBrowser = function(user_agent, vendor, hints, options) {
     else if (includes(user_agent, 'YaBrowser/')) return YANDEX;
     else if (includes(user_agent, WHALE + '/')) return WHALE;
     else if (includes(user_agent, DUCKDUCKGO + '/') || includes(user_agent, 'Ddg/')) return DUCKDUCKGO;
+    else if (includes(user_agent, CLAUDE + '/')) return CLAUDE;
+    else if (includes(user_agent, CODEX + '/')) return CODEX;
+    else if (includes(user_agent, CHATGPT + '/')) return CHATGPT;
     else if (includes(user_agent, 'FBIOS')) return FACEBOOK + ' ' + MOBILE;
     else if (includes(user_agent, 'UCWEB') || includes(user_agent, 'UCBrowser')) return 'UC Browser';
     else if (includes(user_agent, 'CriOS')) return CHROME_IOS;
@@ -166,6 +173,15 @@ const versionRegexes = {
     [BRAVE]: [
         new RegExp(BRAVE + '\\/' + BROWSER_VERSION_REGEX_SUFFIX)
     ],
+    [CLAUDE]: [
+        AI_APP_VERSION_REGEX
+    ],
+    [CODEX]: [
+        AI_APP_VERSION_REGEX
+    ],
+    [CHATGPT]: [
+        AI_APP_VERSION_REGEX
+    ],
     [DUCKDUCKGO]: [
         new RegExp('(DuckDuckGo|Ddg)\\/' + BROWSER_VERSION_REGEX_SUFFIX)
     ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/core",
-  "version": "1.49.2",
+  "version": "1.50.0",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },

package/src/featureFlagLocalEvaluation.ts

@@ -1,7 +1,7 @@
 import { parsePayload } from './featureFlagUtils'
 import type { FeatureFlagValue, JsonType } from './types'
 
-export type FeatureFlagPropertyValue = string | number | (string | number)[] | boolean
+export type FeatureFlagPropertyValue = JsonType
 
 export type FeatureFlagProperty = {
   key: string
@@ -42,6 +42,172 @@ export class InconclusiveMatchError extends Error {
   }
 }
 
+function isTruthyOrFalsyPropertyValue(value: unknown): boolean {
+  if (typeof value === 'boolean') return true
+  if (typeof value === 'string') {
+    const lowercaseValue = value.toLowerCase()
+    return lowercaseValue === 'true' || lowercaseValue === 'false'
+  }
+  if (!Array.isArray(value)) return false
+  for (let index = 0; index < value.length; index++) {
+    if (!isTruthyOrFalsyPropertyValue(index in value ? value[index] : null)) return false
+  }
+  return true
+}
+
+function isTruthyPropertyValue(value: unknown): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'string') return value.toLowerCase() === 'true'
+  if (!Array.isArray(value)) return false
+  for (let index = 0; index < value.length; index++) {
+    if (!isTruthyPropertyValue(index in value ? value[index] : null)) return false
+  }
+  return true
+}
+
+function assertUnicodeScalarString(value: string): void {
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index)
+    if (unit >= 0xd800 && unit <= 0xdbff) {
+      const next = value.charCodeAt(index + 1)
+      if (index + 1 >= value.length || next < 0xdc00 || next > 0xdfff) {
+        throw new InconclusiveMatchError('Cannot stringify an unpaired surrogate like the flags service')
+      }
+      index++
+    } else if (unit >= 0xdc00 && unit <= 0xdfff) {
+      throw new InconclusiveMatchError('Cannot stringify an unpaired surrogate like the flags service')
+    }
+  }
+}
+
+function assertJsonRepresentable(value: unknown, seen: Set<object> = new Set()): void {
+  if (value === null || typeof value === 'boolean') return
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new InconclusiveMatchError(`Cannot represent non-finite number ${value} like the flags service`)
+    }
+    return
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot represent a circular array during local evaluation')
+    seen.add(value)
+    try {
+      for (let index = 0; index < value.length; index++) {
+        if (index in value) assertJsonRepresentable(value[index], seen)
+      }
+    } finally {
+      seen.delete(value)
+    }
+    return
+  }
+  if (typeof value === 'object') {
+    const prototype = Object.getPrototypeOf(value)
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new InconclusiveMatchError('Cannot represent a non-JSON object like the flags service')
+    }
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot represent a circular object during local evaluation')
+    seen.add(value)
+    try {
+      for (const key of Object.keys(value)) {
+        assertUnicodeScalarString(key)
+        assertJsonRepresentable((value as Record<string, unknown>)[key], seen)
+      }
+    } finally {
+      seen.delete(value)
+    }
+    return
+  }
+  throw new InconclusiveMatchError(`Cannot represent ${typeof value} like the flags service`)
+}
+
+function compareJsonObjectKeys(left: string, right: string): number {
+  let leftIndex = 0
+  let rightIndex = 0
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftUnit = left.charCodeAt(leftIndex)
+    const rightUnit = right.charCodeAt(rightIndex)
+    const leftIsHighSurrogate = leftUnit >= 0xd800 && leftUnit <= 0xdbff
+    const rightIsHighSurrogate = rightUnit >= 0xd800 && rightUnit <= 0xdbff
+    const leftNext = leftIsHighSurrogate ? left.charCodeAt(leftIndex + 1) : 0
+    const rightNext = rightIsHighSurrogate ? right.charCodeAt(rightIndex + 1) : 0
+
+    const leftCodePoint = leftIsHighSurrogate ? (leftUnit - 0xd800) * 0x400 + leftNext - 0xdc00 + 0x10000 : leftUnit
+    const rightCodePoint = rightIsHighSurrogate
+      ? (rightUnit - 0xd800) * 0x400 + rightNext - 0xdc00 + 0x10000
+      : rightUnit
+    if (leftCodePoint !== rightCodePoint) return leftCodePoint - rightCodePoint
+    leftIndex += leftIsHighSurrogate ? 2 : 1
+    rightIndex += rightIsHighSurrogate ? 2 : 1
+  }
+  return left.length - right.length
+}
+
+// JavaScript collapses JSON integers and integral floats into Number, including inside composites.
+// These values fall back rather than choosing a spelling that can disagree with the flags service.
+function serializeJsonValue(value: unknown, seen: Set<object> = new Set()): string {
+  if (value === null) return 'null'
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return JSON.stringify(value)
+  }
+  if (typeof value === 'boolean') return value ? 'true' : 'false'
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new InconclusiveMatchError(`Cannot stringify non-finite number ${value} like the flags service`)
+    }
+    if (Number.isInteger(value)) {
+      throw new InconclusiveMatchError(
+        `Cannot distinguish integer ${value} from an integral JSON float during local evaluation`
+      )
+    }
+    return String(value)
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot stringify a circular array during local evaluation')
+    seen.add(value)
+    try {
+      const items: string[] = []
+      for (let index = 0; index < value.length; index++) {
+        items.push(index in value ? serializeJsonValue(value[index], seen) : 'null')
+      }
+      return `[${items.join(',')}]`
+    } finally {
+      seen.delete(value)
+    }
+  }
+  if (typeof value === 'object') {
+    const prototype = Object.getPrototypeOf(value)
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new InconclusiveMatchError('Cannot stringify a non-JSON object like the flags service')
+    }
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot stringify a circular object during local evaluation')
+    seen.add(value)
+    try {
+      const keys = Object.keys(value)
+      keys.forEach(assertUnicodeScalarString)
+      return `{${keys
+        .sort(compareJsonObjectKeys)
+        .map((key) => `${JSON.stringify(key)}:${serializeJsonValue((value as Record<string, unknown>)[key], seen)}`)
+        .join(',')}}`
+    } finally {
+      seen.delete(value)
+    }
+  }
+  throw new InconclusiveMatchError(`Cannot stringify ${typeof value} like the flags service`)
+}
+
+function exactMatchString(value: unknown): string {
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return value
+  }
+  return serializeJsonValue(value)
+}
+
 function isValidRegex(regex: string): boolean {
   try {
     new RegExp(regex)
@@ -51,6 +217,11 @@ function isValidRegex(regex: string): boolean {
   }
 }
 
+// The flags service deliberately folds only ASCII for substring, prefix, and suffix operators.
+function asciiLowercase(value: unknown): string {
+  return String(value).replace(/[A-Z]/g, (character) => character.toLowerCase())
+}
+
 type SemverTuple = [number, number, number]
 
 function parseSemverNumericIdentifier(
@@ -190,19 +361,35 @@ export function matchFeatureFlagProperty(
     throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`)
   } else if (operator === 'is_not_set') {
     return false
+  } else if (operator === 'is_set') {
+    return true
   }
 
   const overrideValue = propertyValues[key]
-  if (overrideValue == null && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
-    options.warnFunction?.(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`)
+  if (overrideValue === undefined) {
+    options.warnFunction?.(`Property ${key} cannot have a value of undefined with the ${operator} operator`)
+    return operator === 'is_not'
+  }
+  if (
+    overrideValue === null &&
+    !NULL_VALUES_ALLOWED_OPERATORS.includes(operator) &&
+    operator !== 'exact' &&
+    operator !== 'is_not'
+  ) {
+    options.warnFunction?.(`Property ${key} cannot have a value of null with the ${operator} operator`)
     return false
   }
 
-  const computeExactMatch = (target: any, actual: any): boolean => {
+  const computeExactMatch = (target: unknown, actual: unknown): boolean => {
+    if (isTruthyOrFalsyPropertyValue(target)) {
+      assertJsonRepresentable(actual)
+      return isTruthyPropertyValue(target) === isTruthyPropertyValue(actual)
+    }
     if (Array.isArray(target)) {
-      return target.map((item) => String(item).toLowerCase()).includes(String(actual).toLowerCase())
+      const actualString = exactMatchString(actual).toLowerCase()
+      return target.some((item) => exactMatchString(item).toLowerCase() === actualString)
     }
-    return String(target).toLowerCase() === String(actual).toLowerCase()
+    return exactMatchString(target).toLowerCase() === exactMatchString(actual).toLowerCase()
   }
 
   const compare = (lhs: any, rhs: any, comparisonOperator: string): boolean => {
@@ -221,17 +408,17 @@ export function matchFeatureFlagProperty(
     case 'is_set':
       return true
     case 'icontains':
-      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).includes(asciiLowercase(value))
     case 'not_icontains':
-      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).includes(asciiLowercase(value))
     case 'starts_with':
-      return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).startsWith(asciiLowercase(value))
     case 'not_starts_with':
-      return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).startsWith(asciiLowercase(value))
     case 'ends_with':
-      return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).endsWith(asciiLowercase(value))
     case 'not_ends_with':
-      return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).endsWith(asciiLowercase(value))
     case 'regex':
       return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null
     case 'not_regex':

package/src/index.ts

@@ -42,9 +42,8 @@ export {
   buildResourceAttributes,
   getOtlpSeverityNumber,
   getOtlpSeverityText,
-  toOtlpAnyValue,
-  toOtlpKeyValueList,
 } from './logs/logs-utils'
+export { toOtlpAnyValue, toOtlpKeyValueList } from './utils/otlp-any-value'
 export { PostHogLogs } from './logs'
 export type {
   BeforeSendLogFn,