@posthog/core 1.48.9 → 1.48.11

package/dist/featureFlagLocalEvaluation.d.ts

@@ -0,0 +1,35 @@
+import type { FeatureFlagValue, JsonType } from './types';
+export type FeatureFlagPropertyValue = string | number | (string | number)[] | boolean;
+export type FeatureFlagProperty = {
+    key: string;
+    value: FeatureFlagPropertyValue;
+    operator?: string;
+};
+export type FeatureFlagSemverParsingPolicy = 'strict' | 'legacy-permissive';
+export type MatchFeatureFlagPropertyOptions = {
+    warnFunction?: (message: string) => void;
+    semverParsingPolicy?: FeatureFlagSemverParsingPolicy;
+};
+export type FeatureFlagVariant = {
+    key: string;
+    rollout_percentage: number;
+};
+export type FeatureFlagVariantLookupEntry = {
+    valueMin: number;
+    valueMax: number;
+    key: string;
+};
+export declare class InconclusiveMatchError extends Error {
+    constructor(message: string);
+}
+type SemverTuple = [number, number, number];
+export declare function parseFeatureFlagSemver(value: string, parsingPolicy?: FeatureFlagSemverParsingPolicy): SemverTuple;
+export declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;
+export declare function matchFeatureFlagProperty(property: FeatureFlagProperty, propertyValues: Record<string, any>, options?: MatchFeatureFlagPropertyOptions): boolean;
+export declare function hashSHA1(text: string): Promise<string>;
+export declare function getFeatureFlagHash(key: string, bucketingValue: string, salt?: string): Promise<number>;
+export declare function getFeatureFlagVariantLookupTable(variants: readonly FeatureFlagVariant[]): FeatureFlagVariantLookupEntry[];
+export declare function getFeatureFlagVariant(key: string, bucketingValue: string, variants: readonly FeatureFlagVariant[]): Promise<string | undefined>;
+export declare function resolveFeatureFlagPayload(payloads: Readonly<Record<string, JsonType | undefined>> | null | undefined, flagValue: FeatureFlagValue | null | undefined): JsonType | null;
+export {};
+//# sourceMappingURL=featureFlagLocalEvaluation.d.ts.map

package/dist/featureFlagLocalEvaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"featureFlagLocalEvaluation.d.ts","sourceRoot":"","sources":["../src/featureFlagLocalEvaluation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEzD,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,OAAO,CAAA;AAEtF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,wBAAwB,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,QAAQ,GAAG,mBAAmB,CAAA;AAE3E,MAAM,MAAM,+BAA+B,GAAG;IAC5C,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,mBAAmB,CAAC,EAAE,8BAA8B,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AASD,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,EAAE,MAAM;CAK5B;AAWD,KAAK,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAa3C,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,aAAa,GAAE,8BAAyC,GACvD,WAAW,CAeb;AAwED,wBAAgB,uCAAuC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAmBlF;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CA+IT;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5D;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,GAAE,MAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAGhH;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GACtC,6BAA6B,EAAE,CASjC;AAED,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GACtC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK7B;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAC3E,SAAS,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GAC7C,QAAQ,GAAG,IAAI,CAMjB"}

package/dist/featureFlagLocalEvaluation.js

@@ -0,0 +1,352 @@
+"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__, {
+    getFeatureFlagHash: ()=>getFeatureFlagHash,
+    relativeDateParseForFeatureFlagMatching: ()=>relativeDateParseForFeatureFlagMatching,
+    InconclusiveMatchError: ()=>InconclusiveMatchError,
+    parseFeatureFlagSemver: ()=>parseFeatureFlagSemver,
+    resolveFeatureFlagPayload: ()=>resolveFeatureFlagPayload,
+    getFeatureFlagVariantLookupTable: ()=>getFeatureFlagVariantLookupTable,
+    hashSHA1: ()=>hashSHA1,
+    matchFeatureFlagProperty: ()=>matchFeatureFlagProperty,
+    getFeatureFlagVariant: ()=>getFeatureFlagVariant
+});
+const external_featureFlagUtils_js_namespaceObject = require("./featureFlagUtils.js");
+const NULL_VALUES_ALLOWED_OPERATORS = [
+    'is_not',
+    'is_set'
+];
+const LONG_SCALE = 0xfffffffffffffff;
+class InconclusiveMatchError extends Error {
+    constructor(message){
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
+    }
+}
+function isValidRegex(regex) {
+    try {
+        new RegExp(regex);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function parseSemverNumericIdentifier(part, raw, parsingPolicy) {
+    if (!/^\d+$/.test(part) || 'strict' === parsingPolicy && part.length > 1 && '0' === part[0]) throw new InconclusiveMatchError(`Invalid semver: ${raw}`);
+    return parseInt(part, 10);
+}
+function parseFeatureFlagSemver(value, parsingPolicy = 'strict') {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const baseVersion = text.split('-')[0].split('+')[0];
+    if (!baseVersion || baseVersion.startsWith('.')) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
+    const parts = baseVersion.split('.');
+    const parsePart = (part)=>{
+        if (void 0 === part || '' === part) return 0;
+        return parseSemverNumericIdentifier(part, value, parsingPolicy);
+    };
+    return [
+        parsePart(parts[0]),
+        parsePart(parts[1]),
+        parsePart(parts[2])
+    ];
+}
+function compareSemverTuples(a, b) {
+    for(let i = 0; i < 3; i++){
+        if (a[i] < b[i]) return -1;
+        if (a[i] > b[i]) return 1;
+    }
+    return 0;
+}
+function computeTildeBounds(value, parsingPolicy) {
+    const parsed = parseFeatureFlagSemver(value, parsingPolicy);
+    return {
+        lower: [
+            parsed[0],
+            parsed[1],
+            parsed[2]
+        ],
+        upper: [
+            parsed[0],
+            parsed[1] + 1,
+            0
+        ]
+    };
+}
+function computeCaretBounds(value, parsingPolicy) {
+    const [major, minor, patch] = parseFeatureFlagSemver(value, parsingPolicy);
+    const lower = [
+        major,
+        minor,
+        patch
+    ];
+    let upper;
+    upper = major > 0 ? [
+        major + 1,
+        0,
+        0
+    ] : minor > 0 ? [
+        0,
+        minor + 1,
+        0
+    ] : [
+        0,
+        0,
+        patch + 1
+    ];
+    return {
+        lower,
+        upper
+    };
+}
+function computeWildcardBounds(value, parsingPolicy) {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const cleanedText = text.replace(/\.\*$/, '').replace(/\*$/, '');
+    if (!cleanedText) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    const parts = cleanedText.split('.');
+    const parseWildcardPart = (part)=>{
+        if ('legacy-permissive' === parsingPolicy) {
+            const parsed = parseInt(part, 10);
+            if (!isNaN(parsed)) return parsed;
+        } else try {
+            return parseSemverNumericIdentifier(part, value, parsingPolicy);
+        } catch  {}
+        throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    };
+    const major = parseWildcardPart(parts[0]);
+    if (1 === parts.length) return {
+        lower: [
+            major,
+            0,
+            0
+        ],
+        upper: [
+            major + 1,
+            0,
+            0
+        ]
+    };
+    const minor = parseWildcardPart(parts[1]);
+    return {
+        lower: [
+            major,
+            minor,
+            0
+        ],
+        upper: [
+            major,
+            minor + 1,
+            0
+        ]
+    };
+}
+function convertToDateTime(value) {
+    if (value instanceof Date) return value;
+    if ('string' == typeof value || 'number' == typeof value) {
+        const date = new Date(value);
+        if (!isNaN(date.valueOf())) return date;
+        throw new InconclusiveMatchError(`${value} is in an invalid date format`);
+    }
+    throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
+}
+function relativeDateParseForFeatureFlagMatching(value) {
+    const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
+    const match = value.match(regex);
+    const parsedDt = new Date(new Date().toISOString());
+    if (!match || !match.groups) return null;
+    const number = parseInt(match.groups['number']);
+    if (number >= 10000) return null;
+    const interval = match.groups['interval'];
+    if ('h' === interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    else if ('d' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    else if ('w' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
+    else if ('m' === interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    else {
+        if ('y' !== interval) return null;
+        parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    }
+    return parsedDt;
+}
+function matchFeatureFlagProperty(property, propertyValues, options = {}) {
+    const key = property.key;
+    const value = property.value;
+    const operator = property.operator || 'exact';
+    const parsingPolicy = options.semverParsingPolicy ?? 'strict';
+    if (key in propertyValues) {
+        if ('is_not_set' === operator) return false;
+    } else {
+        if ('is_not_set' === operator) return true;
+        throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
+    }
+    const overrideValue = propertyValues[key];
+    if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+        options.warnFunction?.(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
+        return false;
+    }
+    const computeExactMatch = (target, actual)=>{
+        if (Array.isArray(target)) return target.map((item)=>String(item).toLowerCase()).includes(String(actual).toLowerCase());
+        return String(target).toLowerCase() === String(actual).toLowerCase();
+    };
+    const compare = (lhs, rhs, comparisonOperator)=>{
+        if ('gt' === comparisonOperator) return lhs > rhs;
+        if ('gte' === comparisonOperator) return lhs >= rhs;
+        if ('lt' === comparisonOperator) return lhs < rhs;
+        if ('lte' === comparisonOperator) return lhs <= rhs;
+        throw new Error(`Invalid operator: ${comparisonOperator}`);
+    };
+    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 'starts_with':
+            return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'not_starts_with':
+            return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'ends_with':
+            return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'not_ends_with':
+            return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'regex':
+            return isValidRegex(String(value)) && null !== String(overrideValue).match(String(value));
+        case 'not_regex':
+            return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            {
+                const parsedValue = 'number' == typeof value ? value : parseFloat(String(value));
+                const parsedOverride = 'number' == typeof overrideValue ? overrideValue : null != overrideValue ? parseFloat(String(overrideValue)) : NaN;
+                if (Number.isFinite(parsedValue) && Number.isFinite(parsedOverride)) return compare(parsedOverride, parsedValue, operator);
+                return compare(String(overrideValue), String(value), operator);
+            }
+        case 'is_date_after':
+        case 'is_date_before':
+            {
+                if ('boolean' == typeof value) throw new InconclusiveMatchError('Date operations cannot be performed on boolean values');
+                let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+                if (null == parsedDate) parsedDate = convertToDateTime(value);
+                const overrideDate = convertToDateTime(overrideValue);
+                return 'is_date_before' === operator ? overrideDate < parsedDate : overrideDate > parsedDate;
+            }
+        case 'semver_eq':
+            return 0 === compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_neq':
+            return 0 !== compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_gt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) > 0;
+        case 'semver_gte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) >= 0;
+        case 'semver_lt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) < 0;
+        case 'semver_lte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) <= 0;
+        case 'semver_tilde':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeTildeBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_caret':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeCaretBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_wildcard':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeWildcardBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        default:
+            throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
+    }
+}
+async function hashSHA1(text) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) throw new Error('SubtleCrypto API not available');
+    const hashBuffer = await subtle.digest('SHA-1', new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(hashBuffer)).map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+}
+async function getFeatureFlagHash(key, bucketingValue, salt = '') {
+    const hashString = await hashSHA1(`${key}.${bucketingValue}${salt}`);
+    return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
+}
+function getFeatureFlagVariantLookupTable(variants) {
+    const table = [];
+    let valueMin = 0;
+    for (const variant of variants){
+        const valueMax = valueMin + variant.rollout_percentage / 100.0;
+        table.push({
+            valueMin,
+            valueMax,
+            key: variant.key
+        });
+        valueMin = valueMax;
+    }
+    return table;
+}
+async function getFeatureFlagVariant(key, bucketingValue, variants) {
+    const hashValue = await getFeatureFlagHash(key, bucketingValue, 'variant');
+    return getFeatureFlagVariantLookupTable(variants).find((variant)=>hashValue >= variant.valueMin && hashValue < variant.valueMax)?.key;
+}
+function resolveFeatureFlagPayload(payloads, flagValue) {
+    if (false === flagValue || null == flagValue || !payloads) return null;
+    const payloadKey = 'boolean' == typeof flagValue ? flagValue.toString() : flagValue;
+    const payload = payloads[payloadKey] || null;
+    return null == payload ? null : (0, external_featureFlagUtils_js_namespaceObject.parsePayload)(payload);
+}
+exports.InconclusiveMatchError = __webpack_exports__.InconclusiveMatchError;
+exports.getFeatureFlagHash = __webpack_exports__.getFeatureFlagHash;
+exports.getFeatureFlagVariant = __webpack_exports__.getFeatureFlagVariant;
+exports.getFeatureFlagVariantLookupTable = __webpack_exports__.getFeatureFlagVariantLookupTable;
+exports.hashSHA1 = __webpack_exports__.hashSHA1;
+exports.matchFeatureFlagProperty = __webpack_exports__.matchFeatureFlagProperty;
+exports.parseFeatureFlagSemver = __webpack_exports__.parseFeatureFlagSemver;
+exports.relativeDateParseForFeatureFlagMatching = __webpack_exports__.relativeDateParseForFeatureFlagMatching;
+exports.resolveFeatureFlagPayload = __webpack_exports__.resolveFeatureFlagPayload;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InconclusiveMatchError",
+    "getFeatureFlagHash",
+    "getFeatureFlagVariant",
+    "getFeatureFlagVariantLookupTable",
+    "hashSHA1",
+    "matchFeatureFlagProperty",
+    "parseFeatureFlagSemver",
+    "relativeDateParseForFeatureFlagMatching",
+    "resolveFeatureFlagPayload"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/featureFlagLocalEvaluation.mjs

@@ -0,0 +1,294 @@
+import { parsePayload } from "./featureFlagUtils.mjs";
+const NULL_VALUES_ALLOWED_OPERATORS = [
+    'is_not',
+    'is_set'
+];
+const LONG_SCALE = 0xfffffffffffffff;
+class InconclusiveMatchError extends Error {
+    constructor(message){
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
+    }
+}
+function isValidRegex(regex) {
+    try {
+        new RegExp(regex);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function parseSemverNumericIdentifier(part, raw, parsingPolicy) {
+    if (!/^\d+$/.test(part) || 'strict' === parsingPolicy && part.length > 1 && '0' === part[0]) throw new InconclusiveMatchError(`Invalid semver: ${raw}`);
+    return parseInt(part, 10);
+}
+function parseFeatureFlagSemver(value, parsingPolicy = 'strict') {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const baseVersion = text.split('-')[0].split('+')[0];
+    if (!baseVersion || baseVersion.startsWith('.')) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
+    const parts = baseVersion.split('.');
+    const parsePart = (part)=>{
+        if (void 0 === part || '' === part) return 0;
+        return parseSemverNumericIdentifier(part, value, parsingPolicy);
+    };
+    return [
+        parsePart(parts[0]),
+        parsePart(parts[1]),
+        parsePart(parts[2])
+    ];
+}
+function compareSemverTuples(a, b) {
+    for(let i = 0; i < 3; i++){
+        if (a[i] < b[i]) return -1;
+        if (a[i] > b[i]) return 1;
+    }
+    return 0;
+}
+function computeTildeBounds(value, parsingPolicy) {
+    const parsed = parseFeatureFlagSemver(value, parsingPolicy);
+    return {
+        lower: [
+            parsed[0],
+            parsed[1],
+            parsed[2]
+        ],
+        upper: [
+            parsed[0],
+            parsed[1] + 1,
+            0
+        ]
+    };
+}
+function computeCaretBounds(value, parsingPolicy) {
+    const [major, minor, patch] = parseFeatureFlagSemver(value, parsingPolicy);
+    const lower = [
+        major,
+        minor,
+        patch
+    ];
+    let upper;
+    upper = major > 0 ? [
+        major + 1,
+        0,
+        0
+    ] : minor > 0 ? [
+        0,
+        minor + 1,
+        0
+    ] : [
+        0,
+        0,
+        patch + 1
+    ];
+    return {
+        lower,
+        upper
+    };
+}
+function computeWildcardBounds(value, parsingPolicy) {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const cleanedText = text.replace(/\.\*$/, '').replace(/\*$/, '');
+    if (!cleanedText) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    const parts = cleanedText.split('.');
+    const parseWildcardPart = (part)=>{
+        if ('legacy-permissive' === parsingPolicy) {
+            const parsed = parseInt(part, 10);
+            if (!isNaN(parsed)) return parsed;
+        } else try {
+            return parseSemverNumericIdentifier(part, value, parsingPolicy);
+        } catch  {}
+        throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    };
+    const major = parseWildcardPart(parts[0]);
+    if (1 === parts.length) return {
+        lower: [
+            major,
+            0,
+            0
+        ],
+        upper: [
+            major + 1,
+            0,
+            0
+        ]
+    };
+    const minor = parseWildcardPart(parts[1]);
+    return {
+        lower: [
+            major,
+            minor,
+            0
+        ],
+        upper: [
+            major,
+            minor + 1,
+            0
+        ]
+    };
+}
+function convertToDateTime(value) {
+    if (value instanceof Date) return value;
+    if ('string' == typeof value || 'number' == typeof value) {
+        const date = new Date(value);
+        if (!isNaN(date.valueOf())) return date;
+        throw new InconclusiveMatchError(`${value} is in an invalid date format`);
+    }
+    throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
+}
+function relativeDateParseForFeatureFlagMatching(value) {
+    const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
+    const match = value.match(regex);
+    const parsedDt = new Date(new Date().toISOString());
+    if (!match || !match.groups) return null;
+    const number = parseInt(match.groups['number']);
+    if (number >= 10000) return null;
+    const interval = match.groups['interval'];
+    if ('h' === interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    else if ('d' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    else if ('w' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
+    else if ('m' === interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    else {
+        if ('y' !== interval) return null;
+        parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    }
+    return parsedDt;
+}
+function matchFeatureFlagProperty(property, propertyValues, options = {}) {
+    const key = property.key;
+    const value = property.value;
+    const operator = property.operator || 'exact';
+    const parsingPolicy = options.semverParsingPolicy ?? 'strict';
+    if (key in propertyValues) {
+        if ('is_not_set' === operator) return false;
+    } else {
+        if ('is_not_set' === operator) return true;
+        throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
+    }
+    const overrideValue = propertyValues[key];
+    if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+        options.warnFunction?.(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
+        return false;
+    }
+    const computeExactMatch = (target, actual)=>{
+        if (Array.isArray(target)) return target.map((item)=>String(item).toLowerCase()).includes(String(actual).toLowerCase());
+        return String(target).toLowerCase() === String(actual).toLowerCase();
+    };
+    const compare = (lhs, rhs, comparisonOperator)=>{
+        if ('gt' === comparisonOperator) return lhs > rhs;
+        if ('gte' === comparisonOperator) return lhs >= rhs;
+        if ('lt' === comparisonOperator) return lhs < rhs;
+        if ('lte' === comparisonOperator) return lhs <= rhs;
+        throw new Error(`Invalid operator: ${comparisonOperator}`);
+    };
+    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 'starts_with':
+            return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'not_starts_with':
+            return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'ends_with':
+            return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'not_ends_with':
+            return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'regex':
+            return isValidRegex(String(value)) && null !== String(overrideValue).match(String(value));
+        case 'not_regex':
+            return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            {
+                const parsedValue = 'number' == typeof value ? value : parseFloat(String(value));
+                const parsedOverride = 'number' == typeof overrideValue ? overrideValue : null != overrideValue ? parseFloat(String(overrideValue)) : NaN;
+                if (Number.isFinite(parsedValue) && Number.isFinite(parsedOverride)) return compare(parsedOverride, parsedValue, operator);
+                return compare(String(overrideValue), String(value), operator);
+            }
+        case 'is_date_after':
+        case 'is_date_before':
+            {
+                if ('boolean' == typeof value) throw new InconclusiveMatchError('Date operations cannot be performed on boolean values');
+                let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+                if (null == parsedDate) parsedDate = convertToDateTime(value);
+                const overrideDate = convertToDateTime(overrideValue);
+                return 'is_date_before' === operator ? overrideDate < parsedDate : overrideDate > parsedDate;
+            }
+        case 'semver_eq':
+            return 0 === compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_neq':
+            return 0 !== compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_gt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) > 0;
+        case 'semver_gte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) >= 0;
+        case 'semver_lt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) < 0;
+        case 'semver_lte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) <= 0;
+        case 'semver_tilde':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeTildeBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_caret':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeCaretBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_wildcard':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeWildcardBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        default:
+            throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
+    }
+}
+async function hashSHA1(text) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) throw new Error('SubtleCrypto API not available');
+    const hashBuffer = await subtle.digest('SHA-1', new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(hashBuffer)).map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+}
+async function getFeatureFlagHash(key, bucketingValue, salt = '') {
+    const hashString = await hashSHA1(`${key}.${bucketingValue}${salt}`);
+    return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
+}
+function getFeatureFlagVariantLookupTable(variants) {
+    const table = [];
+    let valueMin = 0;
+    for (const variant of variants){
+        const valueMax = valueMin + variant.rollout_percentage / 100.0;
+        table.push({
+            valueMin,
+            valueMax,
+            key: variant.key
+        });
+        valueMin = valueMax;
+    }
+    return table;
+}
+async function getFeatureFlagVariant(key, bucketingValue, variants) {
+    const hashValue = await getFeatureFlagHash(key, bucketingValue, 'variant');
+    return getFeatureFlagVariantLookupTable(variants).find((variant)=>hashValue >= variant.valueMin && hashValue < variant.valueMax)?.key;
+}
+function resolveFeatureFlagPayload(payloads, flagValue) {
+    if (false === flagValue || null == flagValue || !payloads) return null;
+    const payloadKey = 'boolean' == typeof flagValue ? flagValue.toString() : flagValue;
+    const payload = payloads[payloadKey] || null;
+    return null == payload ? null : parsePayload(payload);
+}
+export { InconclusiveMatchError, getFeatureFlagHash, getFeatureFlagVariant, getFeatureFlagVariantLookupTable, hashSHA1, matchFeatureFlagProperty, parseFeatureFlagSemver, relativeDateParseForFeatureFlagMatching, resolveFeatureFlagPayload };