@guidelytech/flags 0.0.0-stage → 0.8.0

package/dist/evaluate.cjs

@@ -0,0 +1,835 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/evaluate.ts
+var evaluate_exports = {};
+__export(evaluate_exports, {
+  ARRAY_OPERATORS: () => ARRAY_OPERATORS,
+  ATTRIBUTE_OPERATORS: () => ATTRIBUTE_OPERATORS,
+  BOOLEAN_OPERATORS: () => BOOLEAN_OPERATORS,
+  DATE_OPERATORS: () => DATE_OPERATORS,
+  HASHED_OPERATORS: () => HASHED_OPERATORS,
+  NUMBER_OPERATORS: () => NUMBER_OPERATORS,
+  PRESENCE_OPERATORS: () => PRESENCE_OPERATORS,
+  SEMVER_OPERATORS: () => SEMVER_OPERATORS,
+  TEXT_OPERATORS: () => TEXT_OPERATORS,
+  compareSemver: () => compareSemver,
+  effectiveCoverage: () => effectiveCoverage,
+  evaluateAllFlags: () => evaluateAllFlags,
+  evaluateFlag: () => evaluateFlag,
+  fnv1a32: () => fnv1a32,
+  hashBucket: () => hashBucket,
+  hashConfidential: () => hashConfidential,
+  hashConfidentialAffix: () => hashConfidentialAffix,
+  instantOf: () => instantOf,
+  isOn: () => isOn,
+  isScheduleActive: () => isScheduleActive,
+  jsonEquals: () => jsonEquals,
+  lookupAttribute: () => lookupAttribute,
+  numberOf: () => numberOf,
+  parseSemver: () => parseSemver,
+  sha256Hex: () => sha256Hex,
+  textOf: () => textOf
+});
+module.exports = __toCommonJS(evaluate_exports);
+
+// src/hash.ts
+function utf8(input) {
+  const out = [];
+  for (let i = 0; i < input.length; i++) {
+    let c = input.charCodeAt(i);
+    if (c >= 55296 && c <= 56319 && i + 1 < input.length) {
+      const d = input.charCodeAt(i + 1);
+      if (d >= 56320 && d <= 57343) {
+        c = 65536 + (c - 55296 << 10) + (d - 56320);
+        i++;
+      }
+    }
+    if (c >= 55296 && c <= 57343) c = 65533;
+    if (c < 128) out.push(c);
+    else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+    else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+    else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+  }
+  return Uint8Array.from(out);
+}
+function fnv1a32(bytes) {
+  let h = 2166136261;
+  for (let i = 0; i < bytes.length; i++) {
+    h ^= bytes[i];
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function hashBucket(seed, value) {
+  const inner = fnv1a32(utf8(seed + value));
+  return fnv1a32(utf8(String(inner))) % 1e4 / 1e4;
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(input) {
+  const msg = typeof input === "string" ? utf8(input) : input;
+  const bitLen = msg.length * 8;
+  const padded = new Uint8Array(msg.length + 9 + 63 >> 6 << 6);
+  padded.set(msg);
+  padded[msg.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+  view.setUint32(padded.length - 4, bitLen >>> 0);
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let off = 0; off < padded.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const a2 = w[i - 15], b2 = w[i - 2];
+      const s0 = (a2 >>> 7 | a2 << 25) ^ (a2 >>> 18 | a2 << 14) ^ a2 >>> 3;
+      const s1 = (b2 >>> 17 | b2 << 15) ^ (b2 >>> 19 | b2 << 13) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let i = 0; i < 64; i++) {
+      const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const ch = e & f ^ ~e & g;
+      const t1 = hh + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  let hex = "";
+  for (let i = 0; i < 8; i++) hex += h[i].toString(16).padStart(8, "0");
+  return hex;
+}
+function hashConfidential(salt, value) {
+  if (typeof value === "string") return sha256Hex(salt + value);
+  const s = utf8(salt);
+  const joined = new Uint8Array(s.length + value.length);
+  joined.set(s);
+  joined.set(value, s.length);
+  return sha256Hex(joined);
+}
+function hashConfidentialAffix(salt, part) {
+  return `${utf8(part).length}_${hashConfidential(salt, part)}`;
+}
+
+// src/values.ts
+function textOf(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) return void 0;
+    if (Number.isInteger(v) && Math.abs(v) < 1e21) return v.toFixed(0);
+    return String(v);
+  }
+  if (typeof v === "bigint") return v.toString();
+  return void 0;
+}
+var NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+function numberOf(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+  if (typeof v === "string") {
+    const s = v.trim();
+    if (!NUMERIC.test(s)) return void 0;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function arrayOf(v) {
+  if (Array.isArray(v)) return v;
+  if (typeof v === "string") {
+    const s = v.trim();
+    if (!s.startsWith("[")) return void 0;
+    try {
+      const parsed = JSON.parse(s);
+      return Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+var SEMVER = /^[vV]?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseSemver(v) {
+  const s = typeof v === "number" ? textOf(v) : typeof v === "string" ? v.trim() : void 0;
+  if (s === void 0) return void 0;
+  const m = SEMVER.exec(s);
+  if (!m) return void 0;
+  return { major: Number(m[1]), minor: Number(m[2] ?? 0), patch: Number(m[3] ?? 0), pre: m[4] ? m[4].split(".") : [] };
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareSemver(a, b) {
+  const c = cmp(a.major, b.major) || cmp(a.minor, b.minor) || cmp(a.patch, b.patch);
+  if (c) return c;
+  if (!a.pre.length || !b.pre.length) return a.pre.length ? -1 : b.pre.length ? 1 : 0;
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i], y = b.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y);
+    if (xn && yn) {
+      const d = cmp(Number(x), Number(y));
+      if (d) return d;
+    } else if (xn) return -1;
+    else if (yn) return 1;
+    else if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function daysInMonth(year, month) {
+  if (month === 2) return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28;
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function daysFromCivil(year, month, day) {
+  const y = month <= 2 ? year - 1 : year;
+  const era = Math.floor(y / 400);
+  const yoe = y - era * 400;
+  const doy = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+var ISO = /^(\d{4})-(\d{2})-(\d{2})(?:[Tt ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|z|[+-]\d{2}:\d{2})?)?$/;
+function instantOf(v) {
+  if (v instanceof Date) return Number.isNaN(v.getTime()) ? void 0 : v.getTime();
+  if (typeof v === "number") return Number.isFinite(v) ? v * 1e3 : void 0;
+  if (typeof v !== "string") return void 0;
+  const m = ISO.exec(v.trim());
+  if (!m) return void 0;
+  const [, y, mo, d, h = "0", mi = "0", s = "0", frac, tz] = m;
+  const month = Number(mo), day = Number(d), hour = Number(h), minute = Number(mi), second = Number(s);
+  const year = Number(y);
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month) || hour > 23 || minute > 59 || second > 59) return void 0;
+  let ms = (daysFromCivil(year, month, day) * 86400 + hour * 3600 + minute * 60 + second) * 1e3 + (frac ? Math.floor(Number(`0.${frac}`) * 1e3) : 0);
+  if (tz && tz !== "Z" && tz !== "z") {
+    const sign = tz[0] === "-" ? -1 : 1;
+    ms -= sign * (Number(tz.slice(1, 3)) * 60 + Number(tz.slice(4, 6))) * 6e4;
+  }
+  return ms;
+}
+function jsonEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || a === void 0 || b === void 0) return (a ?? null) === (b ?? null);
+  if (typeof a === "number" && typeof b === "number") return a === b;
+  if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((x, i) => jsonEquals(x, b[i]));
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(b)) {
+    const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+    const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+    return ka.length === kb.length && ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && jsonEquals(a[k], b[k]));
+  }
+  return false;
+}
+function isOn(v) {
+  return !(v === null || v === void 0 || v === false || v === 0 || v === "");
+}
+function jsonTypeOf(v) {
+  if (v === null || v === void 0) return void 0;
+  if (Array.isArray(v)) return "array";
+  if (typeof v === "object") return "object";
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return typeof v;
+  return void 0;
+}
+
+// src/types.ts
+var TEXT_OPERATORS = ["equals", "notEquals", "in", "notIn", "contains", "notContains", "startsWith", "notStartsWith", "endsWith", "notEndsWith", "regex", "notRegex"];
+var NUMBER_OPERATORS = ["numEquals", "numNotEquals", "gt", "gte", "lt", "lte"];
+var SEMVER_OPERATORS = ["semverEquals", "semverNotEquals", "semverGt", "semverGte", "semverLt", "semverLte", "semverIn", "semverNotIn"];
+var DATE_OPERATORS = ["before", "after"];
+var ARRAY_OPERATORS = ["arrayContainsAny", "arrayNotContainsAny", "arrayContainsAll"];
+var BOOLEAN_OPERATORS = ["isTrue", "isFalse"];
+var PRESENCE_OPERATORS = ["exists", "notExists", "isType"];
+var HASHED_OPERATORS = ["equalsHashed", "notEqualsHashed", "inHashed", "notInHashed", "startsWithHashed", "notStartsWithHashed", "endsWithHashed", "notEndsWithHashed", "arrayContainsAnyHashed", "arrayNotContainsAnyHashed"];
+var ATTRIBUTE_OPERATORS = [...TEXT_OPERATORS, ...NUMBER_OPERATORS, ...SEMVER_OPERATORS, ...DATE_OPERATORS, ...ARRAY_OPERATORS, ...BOOLEAN_OPERATORS, ...PRESENCE_OPERATORS, ...HASHED_OPERATORS];
+
+// src/evaluate.ts
+var MAX_DEPTH = 32;
+var CycleError = class extends Error {
+};
+function nowOf(now) {
+  if (now === void 0) return Date.now();
+  if (typeof now === "number") return now;
+  if (now instanceof Date) return now.getTime();
+  return instantOf(now) ?? Date.now();
+}
+function lookupAttribute(attributes, name) {
+  if (Object.prototype.hasOwnProperty.call(attributes, name)) return attributes[name] ?? void 0;
+  if (!name.includes(".")) return void 0;
+  let cur = attributes;
+  for (const part of name.split(".")) {
+    if (cur && typeof cur === "object" && !Array.isArray(cur) && Object.prototype.hasOwnProperty.call(cur, part)) cur = cur[part];
+    else return void 0;
+  }
+  return cur ?? void 0;
+}
+function hashValueOf(attributes, name) {
+  const t = textOf(lookupAttribute(attributes, name));
+  return t === void 0 || t === "" ? void 0 : t;
+}
+function isScheduleActive(schedule, now) {
+  if (!schedule) return true;
+  if (schedule.start) {
+    const start = instantOf(schedule.start);
+    if (start === void 0 || now < start) return false;
+  }
+  if (schedule.end) {
+    const end = instantOf(schedule.end);
+    if (end === void 0 || now >= end) return false;
+  }
+  return true;
+}
+function clamp01(n) {
+  return typeof n === "number" && Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
+}
+function effectiveCoverage(rule, now) {
+  let coverage = clamp01(rule.coverage);
+  let latest = -Infinity;
+  for (const step of rule.ramp ?? []) {
+    const at = instantOf(step.at);
+    if (at !== void 0 && at <= now && at >= latest) {
+      latest = at;
+      coverage = clamp01(step.coverage);
+    }
+  }
+  return coverage;
+}
+var regexCache = /* @__PURE__ */ new Map();
+function compile(pattern, ci) {
+  const k = `${ci ? "i" : "-"}:${pattern}`;
+  let re = regexCache.get(k);
+  if (re === void 0) {
+    try {
+      re = new RegExp(pattern, ci ? "i" : "");
+    } catch {
+      re = null;
+    }
+    if (regexCache.size > 500) regexCache.clear();
+    regexCache.set(k, re);
+  }
+  return re;
+}
+function lower(s, ci) {
+  return ci ? s.toLowerCase() : s;
+}
+function textValues(values, ci) {
+  const out = [];
+  for (const v of values) {
+    const t = textOf(v);
+    if (t !== void 0) out.push(lower(t, ci));
+  }
+  return out;
+}
+function affixMatches(salt, text, values, suffix) {
+  const bytes = utf8(text);
+  return values.some((v) => {
+    if (typeof v !== "string") return false;
+    const sep = v.indexOf("_");
+    if (sep <= 0) return false;
+    const n = Number(v.slice(0, sep));
+    if (!Number.isInteger(n) || n < 0 || n > bytes.length) return false;
+    const part = suffix ? bytes.slice(bytes.length - n) : bytes.slice(0, n);
+    return hashConfidential(salt, part) === v.slice(sep + 1);
+  });
+}
+function evalAttribute(ctx, c) {
+  const raw = lookupAttribute(ctx.attributes, c.attribute);
+  const values = Array.isArray(c.values) ? c.values : [];
+  const op = c.operator;
+  if (op === "notExists") return raw === void 0;
+  if (raw === void 0) return false;
+  const ci = c.caseInsensitive;
+  switch (op) {
+    case "exists":
+      return true;
+    case "isType":
+      return jsonTypeOf(raw) === values[0];
+    case "isTrue":
+      return raw === true || typeof raw === "string" && raw.toLowerCase() === "true";
+    case "isFalse":
+      return raw === false || typeof raw === "string" && raw.toLowerCase() === "false";
+    case "equals":
+    case "notEquals":
+    case "in":
+    case "notIn":
+    case "contains":
+    case "notContains":
+    case "startsWith":
+    case "notStartsWith":
+    case "endsWith":
+    case "notEndsWith": {
+      const t0 = textOf(raw);
+      if (t0 === void 0) return false;
+      const t = lower(t0, ci);
+      const vs = textValues(values, ci);
+      switch (op) {
+        case "equals":
+          return vs.length > 0 && t === vs[0];
+        case "notEquals":
+          return vs.length > 0 && t !== vs[0];
+        case "in":
+          return vs.includes(t);
+        case "notIn":
+          return !vs.includes(t);
+        case "contains":
+          return vs.some((v) => t.includes(v));
+        case "notContains":
+          return !vs.some((v) => t.includes(v));
+        case "startsWith":
+          return vs.some((v) => t.startsWith(v));
+        case "notStartsWith":
+          return !vs.some((v) => t.startsWith(v));
+        case "endsWith":
+          return vs.some((v) => t.endsWith(v));
+        default:
+          return !vs.some((v) => t.endsWith(v));
+      }
+    }
+    case "regex":
+    case "notRegex": {
+      const t = textOf(raw);
+      if (t === void 0) return false;
+      const res = [];
+      for (const v of values) {
+        const re = typeof v === "string" ? compile(v, !!ci) : null;
+        if (!re) return false;
+        res.push(re);
+      }
+      const any = res.some((re) => re.test(t));
+      return op === "regex" ? any : !any;
+    }
+    case "numEquals":
+    case "numNotEquals":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const a = numberOf(raw);
+      const b = numberOf(values[0]);
+      if (a === void 0 || b === void 0) return false;
+      if (op === "numEquals") return a === b;
+      if (op === "numNotEquals") return a !== b;
+      if (op === "gt") return a > b;
+      if (op === "gte") return a >= b;
+      if (op === "lt") return a < b;
+      return a <= b;
+    }
+    case "semverEquals":
+    case "semverNotEquals":
+    case "semverGt":
+    case "semverGte":
+    case "semverLt":
+    case "semverLte":
+    case "semverIn":
+    case "semverNotIn": {
+      const a = parseSemver(raw);
+      if (!a) return false;
+      const bs = values.map(parseSemver);
+      if (bs.some((b) => !b)) return false;
+      if (op === "semverIn") return bs.some((b) => compareSemver(a, b) === 0);
+      if (op === "semverNotIn") return !bs.some((b) => compareSemver(a, b) === 0);
+      if (!bs[0]) return false;
+      const d = compareSemver(a, bs[0]);
+      if (op === "semverEquals") return d === 0;
+      if (op === "semverNotEquals") return d !== 0;
+      if (op === "semverGt") return d > 0;
+      if (op === "semverGte") return d >= 0;
+      if (op === "semverLt") return d < 0;
+      return d <= 0;
+    }
+    case "before":
+    case "after": {
+      const a = instantOf(raw);
+      const b = instantOf(values[0]);
+      if (a === void 0 || b === void 0) return false;
+      return op === "before" ? a < b : a > b;
+    }
+    case "arrayContainsAny":
+    case "arrayNotContainsAny":
+    case "arrayContainsAll": {
+      const arr = arrayOf(raw);
+      if (!arr) return false;
+      const elems = textValues(arr, ci);
+      const vs = textValues(values, ci);
+      if (op === "arrayContainsAll") return vs.every((v) => elems.includes(v));
+      const any = vs.some((v) => elems.includes(v));
+      return op === "arrayContainsAny" ? any : !any;
+    }
+    case "equalsHashed":
+    case "notEqualsHashed":
+    case "inHashed":
+    case "notInHashed":
+    case "startsWithHashed":
+    case "notStartsWithHashed":
+    case "endsWithHashed":
+    case "notEndsWithHashed": {
+      const t = textOf(raw);
+      if (t === void 0) return false;
+      const salt = ctx.payload.salt ?? "";
+      if (op === "startsWithHashed" || op === "notStartsWithHashed" || op === "endsWithHashed" || op === "notEndsWithHashed") {
+        const any = affixMatches(salt, t, values, op === "endsWithHashed" || op === "notEndsWithHashed");
+        return op.startsWith("not") ? !any : any;
+      }
+      const h = hashConfidential(salt, t);
+      if (op === "equalsHashed") return typeof values[0] === "string" && h === values[0];
+      if (op === "notEqualsHashed") return typeof values[0] === "string" && h !== values[0];
+      if (op === "inHashed") return values.includes(h);
+      return !values.includes(h);
+    }
+    case "arrayContainsAnyHashed":
+    case "arrayNotContainsAnyHashed": {
+      const arr = arrayOf(raw);
+      if (!arr) return false;
+      const salt = ctx.payload.salt ?? "";
+      const any = arr.some((e) => {
+        const t = textOf(e);
+        return t !== void 0 && values.includes(hashConfidential(salt, t));
+      });
+      return op === "arrayContainsAnyHashed" ? any : !any;
+    }
+    default:
+      return false;
+  }
+}
+function enter(ctx, frame, fn) {
+  if (ctx.stack.includes(frame)) throw new CycleError(`Cycle detected: ${[...ctx.stack, frame].join(" \u2192 ")}`);
+  if (ctx.stack.length >= MAX_DEPTH) throw new CycleError(`Flag references nest deeper than ${MAX_DEPTH} levels: ${ctx.stack.join(" \u2192 ")}`);
+  ctx.stack.push(frame);
+  try {
+    return fn();
+  } finally {
+    ctx.stack.pop();
+  }
+}
+function segmentMatches(ctx, key) {
+  const seg = ctx.payload.segments?.[key];
+  if (!seg) return void 0;
+  return enter(ctx, `segment:${key}`, () => {
+    if (seg.kind === "list") {
+      const t = textOf(lookupAttribute(ctx.attributes, seg.attribute));
+      if (t === void 0) return false;
+      const needle = seg.hashed ? hashConfidential(ctx.payload.salt ?? "", t) : t;
+      return Array.isArray(seg.values) && seg.values.includes(needle);
+    }
+    if (seg.kind === "conditions") return allMatch(ctx, seg.conditions);
+    return false;
+  });
+}
+function compareFlag(op, actual, expected) {
+  switch (op) {
+    case "isOn":
+      return isOn(actual);
+    case "isOff":
+      return !isOn(actual);
+    case "equals":
+      return jsonEquals(actual, expected ?? null);
+    case "notEquals":
+      return !jsonEquals(actual, expected ?? null);
+    default:
+      return false;
+  }
+}
+function referencedValue(ctx, key) {
+  const res = evalFlag(ctx, key);
+  return res.reason === "FLAG_NOT_FOUND" ? void 0 : { value: res.value };
+}
+function conditionMatches(ctx, c) {
+  if (!c || typeof c !== "object") return false;
+  switch (c.kind) {
+    case "attribute":
+      return evalAttribute(ctx, c);
+    case "segment": {
+      const m = segmentMatches(ctx, c.segment);
+      if (m === void 0) return false;
+      if (c.operator === "in") return m;
+      if (c.operator === "notIn") return !m;
+      return false;
+    }
+    case "flag": {
+      const ref = referencedValue(ctx, c.flag);
+      return ref ? compareFlag(c.operator, ref.value, c.value) : false;
+    }
+    case "group": {
+      const list = Array.isArray(c.conditions) ? c.conditions : [];
+      let r;
+      if (c.op === "and") r = allMatch(ctx, list);
+      else if (c.op === "or") r = list.some((x) => conditionMatches(ctx, x));
+      else return false;
+      return c.negate ? !r : r;
+    }
+    default:
+      return false;
+  }
+}
+function allMatch(ctx, conditions) {
+  if (!conditions) return true;
+  for (const c of conditions) if (!conditionMatches(ctx, c)) return false;
+  return true;
+}
+function base(flag, value, reason) {
+  return { key: flag.key, value: value === void 0 ? null : value, reason, inExperiment: false };
+}
+function stickyDocKey(attribute, value) {
+  return `${attribute}||${value}`;
+}
+function runExperiment(ctx, flag, rule) {
+  const variations = Array.isArray(rule.variations) ? rule.variations : [];
+  if (!variations.length) return void 0;
+  let hashAttribute = rule.hashAttribute;
+  let hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+  const fallbackValue = rule.fallbackAttribute ? hashValueOf(ctx.attributes, rule.fallbackAttribute) : void 0;
+  if (hv === void 0 && rule.fallbackAttribute && fallbackValue !== void 0) {
+    hashAttribute = rule.fallbackAttribute;
+    hv = fallbackValue;
+  }
+  if (hv === void 0) return void 0;
+  const bucketVersion = rule.bucketVersion ?? 0;
+  const useSticky = !!ctx.sticky && !rule.disableStickyBucketing;
+  let index = -1;
+  const bucket = hashBucket(rule.seed, hv);
+  let stickyUsed = false;
+  if (useSticky) {
+    const merged = {};
+    if (rule.fallbackAttribute && fallbackValue !== void 0) Object.assign(merged, ctx.sticky.get(stickyDocKey(rule.fallbackAttribute, fallbackValue)) ?? {});
+    const primary = hashValueOf(ctx.attributes, rule.hashAttribute);
+    if (primary !== void 0) Object.assign(merged, ctx.sticky.get(stickyDocKey(rule.hashAttribute, primary)) ?? {});
+    const prefix = `${rule.key}__`;
+    const minVersion = rule.minBucketVersion ?? 0;
+    for (const k of Object.keys(merged)) {
+      if (!k.startsWith(prefix)) continue;
+      const v = Number(k.slice(prefix.length));
+      if (Number.isInteger(v) && v < minVersion) return void 0;
+    }
+    const assigned = merged[`${prefix}${bucketVersion}`];
+    if (assigned !== void 0) {
+      const i = variations.findIndex((v) => v.id === assigned);
+      if (i >= 0) {
+        index = i;
+        stickyUsed = true;
+      }
+    }
+  }
+  if (index < 0) {
+    if (rule.namespace) {
+      const n = hashBucket(`__${rule.namespace.id}`, hv);
+      if (!(n >= rule.namespace.start && n < rule.namespace.end)) return void 0;
+    }
+    const coverage = clamp01(rule.coverage);
+    let cum = 0;
+    for (let i = 0; i < variations.length; i++) {
+      const w = Math.max(0, Number(variations[i].weight) || 0);
+      const start = cum;
+      const end = cum + coverage * w;
+      cum += w;
+      if (bucket >= start && bucket < end) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return void 0;
+    if (useSticky) {
+      const docKey = stickyDocKey(hashAttribute, hv);
+      const doc = { ...ctx.sticky.get(docKey) ?? {} };
+      doc[`${rule.key}__${bucketVersion}`] = variations[index].id;
+      ctx.sticky.set(docKey, doc);
+    }
+  }
+  const variation = variations[index];
+  return {
+    key: flag.key,
+    value: variation.value === void 0 ? null : variation.value,
+    reason: "EXPERIMENT",
+    ruleId: rule.id,
+    variationId: variation.id,
+    inExperiment: true,
+    experiment: { key: rule.key, name: rule.name, variationId: variation.id, variationName: variation.name, variationIndex: index, hashAttribute, hashValue: hv, bucket, stickyBucketUsed: stickyUsed }
+  };
+}
+function applyRule(ctx, flag, rule) {
+  switch (rule.type) {
+    case "force":
+      return { ...base(flag, rule.value, "RULE_MATCH"), ruleId: rule.id, ...rule.variationId ? { variationId: rule.variationId } : {} };
+    case "rollout": {
+      const hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+      if (hv === void 0) return void 0;
+      if (hashBucket(rule.seed, hv) >= effectiveCoverage(rule, ctx.now)) return void 0;
+      return { ...base(flag, rule.value, "RULE_MATCH"), ruleId: rule.id, ...rule.variationId ? { variationId: rule.variationId } : {} };
+    }
+    case "split": {
+      const hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+      if (hv === void 0 || !Array.isArray(rule.buckets)) return void 0;
+      const n = hashBucket(rule.seed, hv);
+      let cum = 0;
+      for (const b of rule.buckets) {
+        cum += Math.max(0, Number(b.weight) || 0);
+        if (n < cum) return { ...base(flag, b.value, "RULE_MATCH"), ruleId: rule.id, ...b.variationId ? { variationId: b.variationId } : {} };
+      }
+      return void 0;
+    }
+    case "experiment":
+      return runExperiment(ctx, flag, rule);
+    default:
+      return void 0;
+  }
+}
+function evalFlag(ctx, key) {
+  const flag = ctx.payload.flags?.[key];
+  if (!flag) return { key, value: null, reason: "FLAG_NOT_FOUND", inExperiment: false };
+  return enter(ctx, `flag:${key}`, () => {
+    if (!flag.enabled) return base(flag, flag.offValue, "DISABLED");
+    for (const p of flag.prerequisites ?? []) {
+      const ref = referencedValue(ctx, p.flag);
+      if (!ref || !compareFlag(p.operator, ref.value, p.value)) return base(flag, flag.offValue, "PREREQUISITE_FAILED");
+    }
+    for (const h of ctx.payload.holdouts ?? []) {
+      if (!Array.isArray(h.flags) || !h.flags.includes(key)) continue;
+      const hv = hashValueOf(ctx.attributes, h.hashAttribute);
+      if (hv !== void 0 && hashBucket(h.seed, hv) < clamp01(h.coverage)) return base(flag, flag.defaultValue, "HOLDOUT");
+    }
+    for (const rule of flag.rules ?? []) {
+      if (!rule || !isScheduleActive(rule.schedule, ctx.now)) continue;
+      if (!allMatch(ctx, rule.conditions)) continue;
+      const res = applyRule(ctx, flag, rule);
+      if (res) return res;
+    }
+    return base(flag, flag.defaultValue, "DEFAULT");
+  });
+}
+function evaluateFlag(payload, key, attributes = {}, options = {}) {
+  const ctx = { payload, attributes: attributes ?? {}, now: nowOf(options.now), sticky: options.stickyBuckets, stack: [] };
+  try {
+    return evalFlag(ctx, key);
+  } catch (err) {
+    return { key, value: null, reason: "ERROR", inExperiment: false, errorMessage: err instanceof Error ? err.message : String(err) };
+  }
+}
+function evaluateAllFlags(payload, attributes = {}, options = {}) {
+  const out = {};
+  for (const key of Object.keys(payload.flags ?? {})) out[key] = evaluateFlag(payload, key, attributes, options);
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARRAY_OPERATORS,
+  ATTRIBUTE_OPERATORS,
+  BOOLEAN_OPERATORS,
+  DATE_OPERATORS,
+  HASHED_OPERATORS,
+  NUMBER_OPERATORS,
+  PRESENCE_OPERATORS,
+  SEMVER_OPERATORS,
+  TEXT_OPERATORS,
+  compareSemver,
+  effectiveCoverage,
+  evaluateAllFlags,
+  evaluateFlag,
+  fnv1a32,
+  hashBucket,
+  hashConfidential,
+  hashConfidentialAffix,
+  instantOf,
+  isOn,
+  isScheduleActive,
+  jsonEquals,
+  lookupAttribute,
+  numberOf,
+  parseSemver,
+  sha256Hex,
+  textOf
+});
+//# sourceMappingURL=evaluate.cjs.map