@zuplo/cli 7.4.5 → 7.4.7

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/key_management.js

@@ -5,7 +5,7 @@ import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { decodeBase64url, digest } from './helpers.js';
 import { generateCek, encrypt, decrypt } from './content_encryption.js';
-import { isObject } from './type_checks.js';
+import { assertUint8Array, isObject } from './type_checks.js';
 import { checkCryptoKey, checkModulusLength, checkUsage } from './crypto_key.js';
 import { concat, encode, uint32be } from './buffer_utils.js';
 import { assertCryptoKey } from './is_key_like.js';
@@ -110,7 +110,7 @@ function assertNoEncryptedKey(encryptedKey) {
     if (encryptedKey !== undefined)
         throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
 }
-export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHeader, options) {
+export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHeader, maxPBES2Count) {
     const entry = jweAlgorithm(alg);
     if (alg === 'dir') {
         assertNoEncryptedKey(encryptedKey);
@@ -152,7 +152,7 @@ export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHead
             assertEncryptedKey(encryptedKey);
             if (typeof joseHeader.p2c !== 'number')
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
-            const p2cLimit = options?.maxPBES2Count || 10_000;
+            const p2cLimit = maxPBES2Count || 10_000;
             if (joseHeader.p2c > p2cLimit)
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
             if (typeof joseHeader.p2s !== 'string')
@@ -190,8 +190,14 @@ export async function encryptKeyManagement(alg, enc, key, providedCek, providedP
         case 'ECDH': {
             assertEcdhKey(key);
             const { apu, apv } = providedParameters;
+            if (apu !== undefined) {
+                assertUint8Array(apu, '"apu"');
+            }
+            if (apv !== undefined) {
+                assertUint8Array(apv, '"apv"');
+            }
             let ephemeralKey;
-            if (providedParameters.epk) {
+            if (providedParameters.epk !== undefined) {
                 ephemeralKey = (await prepareKey(entry, providedParameters.epk, 'decrypt'));
             }
             else {

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/key_options.js

@@ -0,0 +1,6 @@
+export function validateExtractableOption(extractable) {
+    if (extractable !== undefined && typeof extractable !== 'boolean') {
+        throw new TypeError('"extractable" option must be a boolean');
+    }
+    return extractable;
+}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/options.js

@@ -1,4 +1,5 @@
 import { JOSENotSupported, JWEInvalid, JWSInvalid } from '../util/errors.js';
+import { isObject } from './type_checks.js';
 export const JWS_RECOGNIZED = { __proto__: null, b64: true };
 export const JWE_RECOGNIZED = { __proto__: null };
 export function validateAlgorithms(option, algorithms) {
@@ -46,3 +47,28 @@ export function validateCrit(Err, recognizedDefault, recognizedOption, protected
     }
     return protectedHeader.crit;
 }
+export function validateB64(protectedHeader, extensions) {
+    if (extensions.includes('b64')) {
+        const b64 = protectedHeader.b64;
+        if (typeof b64 !== 'boolean') {
+            throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
+        }
+        return b64;
+    }
+    return true;
+}
+export function serializeJoseHeader(Err, header) {
+    let serialized;
+    let parsed;
+    try {
+        serialized = JSON.stringify(header);
+        parsed = JSON.parse(serialized);
+    }
+    catch (cause) {
+        throw new Err('JOSE Header is not valid JSON', { cause });
+    }
+    if (!isObject(parsed)) {
+        throw new Err('JOSE Header is not a JSON object');
+    }
+    return [parsed, serialized];
+}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/type_checks.js

@@ -1,3 +1,8 @@
+export function assertUint8Array(input, label) {
+    if (!(input instanceof Uint8Array)) {
+        throw new TypeError(`${label} must be an instance of Uint8Array`);
+    }
+}
 export function isObject(input) {
     if (typeof input !== 'object' ||
         input === null ||
@@ -5,14 +10,12 @@ export function isObject(input) {
         return false;
     }
     const prototype = Object.getPrototypeOf(input);
-    if (prototype === null) {
-        return true;
-    }
-    let proto = prototype;
-    while (Object.getPrototypeOf(proto) !== null) {
-        proto = Object.getPrototypeOf(proto);
-    }
-    return prototype === proto;
+    return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+export function isJwkSet(input) {
+    return (isObject(input) &&
+        Array.isArray(input.keys) &&
+        Array.from(input.keys).every(isObject));
 }
 export function isDisjoint(...headers) {
     const parameters = new Set();
@@ -28,8 +31,3 @@ export function isDisjoint(...headers) {
     }
     return true;
 }
-export const isJWK = (key) => isObject(key) && typeof key.kty === 'string';
-export const isPrivateJWK = (key) => key.kty !== 'oct' &&
-    ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string');
-export const isPublicJWK = (key) => key.kty !== 'oct' && key.d === undefined && key.priv === undefined;
-export const isSecretJWK = (key) => key.kty === 'oct' && typeof key.k === 'string';

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.2.9",
+  "version": "6.2.10",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "akp",

package/node_modules/@posthog/core/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/node_modules/@posthog/core/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/node_modules/@posthog/core/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
+});