@posthog/core 1.49.2 → 1.50.1

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

@@ -0,0 +1,203 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    toOtlpKeyValueList: ()=>toOtlpKeyValueList,
+    toOtlpAnyValue: ()=>toOtlpAnyValue
+});
+const external_type_utils_js_namespaceObject = require("./type-utils.js");
+const external_json_utils_js_namespaceObject = require("./json-utils.js");
+const INT64_RANGE_LIMIT = 9223372036854775808;
+const INT64_RANGE_LIMIT_DECIMAL = '9223372036854775808';
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+function newState() {
+    return {
+        ancestors: new WeakSet(),
+        remainingNodes: external_json_utils_js_namespaceObject.MAX_JSON_SAFE_VALUE_NODES
+    };
+}
+function toOtlpAnyValue(value, logger) {
+    try {
+        return encodeAnyValue(value, logger, newState(), 0);
+    } catch  {
+        return {
+            stringValue: external_json_utils_js_namespaceObject.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: external_json_utils_js_namespaceObject.TRUNCATED_VALUE
+    };
+    state.remainingNodes--;
+    if ((0, external_type_utils_js_namespaceObject.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: (0, external_json_utils_js_namespaceObject.sanitizeString)(value)
+    };
+    if ('function' == typeof value) return {
+        stringValue: external_json_utils_js_namespaceObject.FUNCTION_VALUE
+    };
+    if ('symbol' == typeof value) return {
+        stringValue: String(value)
+    };
+    if ('object' == typeof value && null !== value) {
+        if (state.ancestors.has(value)) return {
+            stringValue: external_json_utils_js_namespaceObject.CIRCULAR_VALUE
+        };
+        if (depth >= external_json_utils_js_namespaceObject.MAX_JSON_SAFE_VALUE_DEPTH) return {
+            stringValue: external_json_utils_js_namespaceObject.TRUNCATED_VALUE
+        };
+        if (value instanceof Date) {
+            const time = value.getTime();
+            const iso = Number.isFinite(time) ? value.toISOString() : String(value);
+            return {
+                stringValue: 'string' == typeof iso ? (0, external_json_utils_js_namespaceObject.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 ((0, external_type_utils_js_namespaceObject.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: (0, external_json_utils_js_namespaceObject.sanitizeString)(String(value))
+    };
+}
+function encodeArrayValues(values, logger, state, depth) {
+    const result = [];
+    const itemCount = Math.min(values.length, external_json_utils_js_namespaceObject.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 ((0, external_type_utils_js_namespaceObject.isNullish)(element)) continue;
+        result.push(encodeAnyValue(element, logger, state, depth));
+    } catch  {
+        result.push({
+            stringValue: external_json_utils_js_namespaceObject.UNSERIALIZABLE_VALUE
+        });
+    }
+    if (values.length > index) result.push({
+        stringValue: external_json_utils_js_namespaceObject.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 >= external_json_utils_js_namespaceObject.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 ((0, external_type_utils_js_namespaceObject.isNull)(value) || (0, external_type_utils_js_namespaceObject.isUndefined)(value)) continue;
+            result.push({
+                key: (0, external_json_utils_js_namespaceObject.sanitizeString)(key),
+                value: encodeAnyValue(value, logger, state, depth)
+            });
+        } catch  {
+            result.push({
+                key: (0, external_json_utils_js_namespaceObject.sanitizeString)(key),
+                value: {
+                    stringValue: external_json_utils_js_namespaceObject.UNSERIALIZABLE_VALUE
+                }
+            });
+        }
+    }
+    return result;
+}
+exports.toOtlpAnyValue = __webpack_exports__.toOtlpAnyValue;
+exports.toOtlpKeyValueList = __webpack_exports__.toOtlpKeyValueList;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "toOtlpAnyValue",
+    "toOtlpKeyValueList"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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/otlp-resource.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shape the logs and metrics resolved configs share for resource
+ * attribution. Generic over the attribute value type so each signal keeps its
+ * own value union.
+ */
+export interface OtlpResourceConfig<TAttributeValue> {
+    serviceName?: string;
+    serviceVersion?: string;
+    environment?: string;
+    resourceAttributes?: Record<string, TAttributeValue>;
+}
+/**
+ * OTLP resource attributes shared by the logs and metrics envelopes.
+ *
+ * User `resourceAttributes` are spread first, then SDK-controlled keys on top so
+ * a stray user key can't clobber the ingestion-attribution ones; the dedicated
+ * `serviceName` / `environment` / `serviceVersion` fields are how you override
+ * those three.
+ *
+ * @internal Shared within this SDK; not part of the stable public API.
+ */
+export declare function buildOtlpResourceAttributes<TAttributeValue>(config: OtlpResourceConfig<TAttributeValue>, sdkName: string, sdkVersion: string): Record<string, TAttributeValue | string>;
+/**
+ * Normalizes a natively-detected OS name against the table above.
+ * Unrecognized names pass through: a wrong-looking value beats dropping an OS
+ * we have not mapped yet.
+ *
+ * @internal Shared within this SDK; not part of the stable public API.
+ */
+export declare function normalizeOsName(name: string | undefined): string | undefined;
+/**
+ * The `os.name` / `os.version` resource attribute pair, with either key omitted
+ * rather than emitted empty when the host cannot determine it.
+ *
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export declare function osResourceAttributes(name: string | undefined, version: string | undefined): Record<string, string>;
+//# sourceMappingURL=otlp-resource.d.ts.map

package/dist/utils/otlp-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-resource.d.ts","sourceRoot":"","sources":["../../src/utils/otlp-resource.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,kBAAkB,CAAC,eAAe;IACjD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;CACrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,eAAe,EACzD,MAAM,EAAE,kBAAkB,CAAC,eAAe,CAAC,EAC3C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAAC,CAS1C;AA2BD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMlH"}

package/dist/utils/otlp-resource.js

@@ -0,0 +1,81 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildOtlpResourceAttributes: ()=>buildOtlpResourceAttributes,
+    normalizeOsName: ()=>normalizeOsName,
+    osResourceAttributes: ()=>osResourceAttributes
+});
+function buildOtlpResourceAttributes(config, sdkName, sdkVersion) {
+    return {
+        ...config.resourceAttributes,
+        'service.name': config.serviceName || 'unknown_service',
+        ...config.environment && {
+            'deployment.environment': config.environment
+        },
+        ...config.serviceVersion && {
+            'service.version': config.serviceVersion
+        },
+        'telemetry.sdk.name': sdkName,
+        'telemetry.sdk.version': sdkVersion
+    };
+}
+const OS_NAMES = {
+    darwin: 'macOS',
+    win32: 'Windows',
+    linux: 'Linux',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'SunOS',
+    aix: 'AIX',
+    'Mac OS X': 'macOS'
+};
+function normalizeOsName(name) {
+    if (!name) return;
+    return Object.prototype.hasOwnProperty.call(OS_NAMES, name) ? OS_NAMES[name] : name;
+}
+function osResourceAttributes(name, version) {
+    const osName = normalizeOsName(name);
+    return {
+        ...osName ? {
+            'os.name': osName
+        } : {},
+        ...version ? {
+            'os.version': version
+        } : {}
+    };
+}
+exports.buildOtlpResourceAttributes = __webpack_exports__.buildOtlpResourceAttributes;
+exports.normalizeOsName = __webpack_exports__.normalizeOsName;
+exports.osResourceAttributes = __webpack_exports__.osResourceAttributes;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "buildOtlpResourceAttributes",
+    "normalizeOsName",
+    "osResourceAttributes"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/otlp-resource.mjs

@@ -0,0 +1,41 @@
+function buildOtlpResourceAttributes(config, sdkName, sdkVersion) {
+    return {
+        ...config.resourceAttributes,
+        'service.name': config.serviceName || 'unknown_service',
+        ...config.environment && {
+            'deployment.environment': config.environment
+        },
+        ...config.serviceVersion && {
+            'service.version': config.serviceVersion
+        },
+        'telemetry.sdk.name': sdkName,
+        'telemetry.sdk.version': sdkVersion
+    };
+}
+const OS_NAMES = {
+    darwin: 'macOS',
+    win32: 'Windows',
+    linux: 'Linux',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'SunOS',
+    aix: 'AIX',
+    'Mac OS X': 'macOS'
+};
+function normalizeOsName(name) {
+    if (!name) return;
+    return Object.prototype.hasOwnProperty.call(OS_NAMES, name) ? OS_NAMES[name] : name;
+}
+function osResourceAttributes(name, version) {
+    const osName = normalizeOsName(name);
+    return {
+        ...osName ? {
+            'os.name': osName
+        } : {},
+        ...version ? {
+            'os.version': version
+        } : {}
+    };
+}
+export { buildOtlpResourceAttributes, normalizeOsName, osResourceAttributes };

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.1",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },