@osqd/jql 0.1.1 → 0.1.2

package/dist/chunk-2ZMIVDES.cjs

@@ -0,0 +1,1661 @@
+'use strict';
+
+var chunkEJFHVGBC_cjs = require('./chunk-EJFHVGBC.cjs');
+var chunkITPY6VTV_cjs = require('./chunk-ITPY6VTV.cjs');
+var chunk74QKHM6Y_cjs = require('./chunk-74QKHM6Y.cjs');
+
+// src/limits.ts
+var DEFAULT_LIMITS = Object.freeze({
+  maxDepth: 32,
+  maxNodes: 1e4,
+  maxPatternLength: 1024,
+  maxGlobLength: 1024,
+  maxTextDepth: 16,
+  allowRegex: true,
+  allowOperators: "all"
+});
+var UNTRUSTED_LIMITS = Object.freeze({
+  maxDepth: 16,
+  maxNodes: 512,
+  maxPatternLength: 0,
+  maxGlobLength: 256,
+  maxTextDepth: 8,
+  allowRegex: false,
+  // Still every operator but `$regex`: which of the rest an endpoint wants is a decision
+  // only that endpoint can make, and a list guessed here would be one nobody had chosen.
+  allowOperators: "all"
+});
+
+// src/internal/closest.ts
+function closest(word, candidates) {
+  let best;
+  let bestDistance = 3;
+  for (const candidate of candidates) {
+    const distance = editDistance(word.toLowerCase(), candidate.toLowerCase(), bestDistance);
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function editDistance(a, b, ceiling) {
+  if (Math.abs(a.length - b.length) >= ceiling) return ceiling;
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    let rowBest = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+      current.push(value);
+      if (value < rowBest) rowBest = value;
+    }
+    if (rowBest >= ceiling) return ceiling;
+    previous = current;
+  }
+  return previous[b.length];
+}
+function didYouMean(word, candidates) {
+  const guess = closest(word, candidates);
+  return guess === void 0 ? "" : `; did you mean "${guess}"?`;
+}
+
+// src/internal/path.ts
+var FANOUT = /* @__PURE__ */ Symbol("jql.fanout");
+var INDEX = /^(?:0|[1-9]\d{0,8})$/;
+var INHERITED = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(Object.prototype), ...Object.getOwnPropertyNames(Map.prototype), "__proto__"]);
+function needsGuard(key) {
+  return INHERITED.has(key);
+}
+var PLAIN = Object.prototype;
+function segment(key) {
+  return { key, index: INDEX.test(key) ? Number(key) : -1 };
+}
+function readOwn(value, key) {
+  if (value instanceof Map) return value.get(key);
+  return Object.hasOwn(value, key) ? value[key] : void 0;
+}
+function readOne(value, step) {
+  return readOwn(value, step.key);
+}
+var readSelf = (document) => document;
+function reachPath(keys) {
+  const steps = keys.map(segment);
+  return (document, test) => {
+    let value = document;
+    for (let at = 0; at < steps.length; at++) {
+      if (value === null || typeof value !== "object") return test(void 0);
+      if (Array.isArray(value)) return walk(value, steps, at, test);
+      value = readOne(value, steps[at]);
+    }
+    return test(value);
+  };
+}
+function probePath(keys) {
+  const steps = keys.map(segment);
+  const last = steps.length - 1;
+  const [first, second] = steps;
+  if (steps.length === 1 && first.index === -1) {
+    const only = first.key;
+    const guarded = needsGuard(only);
+    return (document) => {
+      if (document === null || typeof document !== "object") return void 0;
+      if (Array.isArray(document)) return FANOUT;
+      if (!guarded && document.__proto__ === PLAIN) return document[only];
+      return readOwn(document, only);
+    };
+  }
+  if (steps.length === 2 && first.index === -1 && second.index === -1) {
+    const outer = first.key;
+    const inner = second.key;
+    const outerGuarded = needsGuard(outer);
+    const innerGuarded = needsGuard(inner);
+    return (document) => {
+      if (document === null || typeof document !== "object") return void 0;
+      if (Array.isArray(document)) return FANOUT;
+      const value = !outerGuarded && document.__proto__ === PLAIN ? document[outer] : readOwn(document, outer);
+      if (value === null || typeof value !== "object") return void 0;
+      if (Array.isArray(value)) return FANOUT;
+      return !innerGuarded && value.__proto__ === PLAIN ? value[inner] : readOwn(value, inner);
+    };
+  }
+  return (document) => {
+    let value = document;
+    for (let at = 0; at <= last; at++) {
+      if (value === null || typeof value !== "object") return void 0;
+      if (Array.isArray(value) && steps[at].index === -1) return FANOUT;
+      const step = steps[at];
+      value = Array.isArray(value) ? value[step.index] : readOwn(value, step.key);
+    }
+    return value;
+  };
+}
+function probeFrom(read, keys) {
+  const probe = probePath(keys);
+  return (document) => probe(read(document));
+}
+function reachFrom(read, keys) {
+  const steps = keys.map(segment);
+  return (document, test) => walk(read(document), steps, 0, test);
+}
+var MAX_DOCUMENT_DEPTH = 512;
+function walk(value, steps, at, test, depth = 0) {
+  if (at === steps.length) return test(value);
+  if (value === null || typeof value !== "object" || depth > MAX_DOCUMENT_DEPTH) return test(void 0);
+  const step = steps[at];
+  if (Array.isArray(value)) {
+    if (step.index !== -1) return walk(value[step.index], steps, at + 1, test, depth + 1);
+    if (value.length === 0) return test(void 0);
+    for (let i = 0; i < value.length; i++) if (walk(value[i], steps, at, test, depth + 1)) return true;
+    return false;
+  }
+  return walk(readOne(value, step), steps, at + 1, test, depth + 1);
+}
+var MAX_PATH_SEGMENTS = 512;
+function splitPath(path) {
+  if (path === "") return "an empty field name reaches nothing";
+  const keys = path.split(".");
+  if (keys.length > MAX_PATH_SEGMENTS) {
+    return `the path has ${keys.length} segments, past the limit of ${MAX_PATH_SEGMENTS}; nothing nests that deep`;
+  }
+  for (const key of keys) if (key === "") return `the path "${path.length > 80 ? `${path.slice(0, 80)}\u2026` : path}" has an empty segment, which reaches nothing`;
+  return keys;
+}
+
+// src/internal/equal.ts
+function sameInteger(a, b) {
+  const big = typeof a === "bigint" ? a : typeof b === "bigint" ? b : void 0;
+  const other = typeof a === "bigint" ? b : a;
+  if (big === void 0) return false;
+  if (typeof other === "bigint") return big === other;
+  return typeof other === "number" && Number.isInteger(other) && big === BigInt(other);
+}
+var MAX_EQUAL_DEPTH = 64;
+function alsoBig(literal) {
+  return typeof literal === "number" && Number.isInteger(literal) ? BigInt(literal) : void 0;
+}
+function equalsLiteral(literal, now, ignoreCase = false) {
+  if (literal === null) return (value) => value === null;
+  if (typeof literal !== "object") {
+    if (ignoreCase && typeof literal === "string") {
+      const wanted = literal.toLowerCase();
+      return (value) => typeof value === "string" && value.toLowerCase() === wanted;
+    }
+    const big = alsoBig(literal);
+    if (big !== void 0) return (value) => value === literal || value === big;
+    return (value) => value === literal;
+  }
+  if (chunk74QKHM6Y_cjs.isDateLiteral(literal)) {
+    const time = chunk74QKHM6Y_cjs.resolveDate(literal.$date, now);
+    return (value) => chunk74QKHM6Y_cjs.toTime(value) === time;
+  }
+  return (value) => deepEqual(value, literal, 0, ignoreCase, now);
+}
+function valuesEqual(a, b) {
+  if (a === void 0 || b === void 0) return false;
+  if (a instanceof Date || b instanceof Date) {
+    const left = chunk74QKHM6Y_cjs.toTime(a);
+    const right = chunk74QKHM6Y_cjs.toTime(b);
+    return a instanceof Date && b instanceof Date && left === right && !Number.isNaN(left);
+  }
+  return deepEqual(a, b, 0);
+}
+function deepEqual(actual, wanted, depth, ignoreCase = false, now = 0) {
+  if (actual === wanted) return true;
+  if (typeof actual === "bigint" || typeof wanted === "bigint") return sameInteger(actual, wanted);
+  if (actual instanceof Date && wanted instanceof Date) return actual.getTime() === wanted.getTime();
+  if (depth > MAX_EQUAL_DEPTH) return false;
+  if (ignoreCase && typeof actual === "string" && typeof wanted === "string") return actual.toLowerCase() === wanted.toLowerCase();
+  if (wanted === null || typeof wanted !== "object") return false;
+  if (chunk74QKHM6Y_cjs.isDateLiteral(wanted)) return chunk74QKHM6Y_cjs.toTime(actual) === chunk74QKHM6Y_cjs.resolveDate(wanted.$date, now);
+  if (actual === null || typeof actual !== "object") return false;
+  if (Array.isArray(wanted)) {
+    if (!Array.isArray(actual) || actual.length !== wanted.length) return false;
+    for (let i = 0; i < wanted.length; i++) if (!deepEqual(actual[i], wanted[i], depth + 1, ignoreCase, now)) return false;
+    return true;
+  }
+  if (Array.isArray(actual) || !chunk74QKHM6Y_cjs.isPlainObject(wanted)) return false;
+  if (actual instanceof Map) {
+    let size2 = 0;
+    for (const key in wanted) {
+      const expected = wanted[key];
+      if (expected === void 0) continue;
+      size2++;
+      if (!actual.has(key) || !deepEqual(actual.get(key), expected, depth + 1, ignoreCase, now)) return false;
+    }
+    let present2 = 0;
+    for (const value of actual.values()) if (value !== void 0) present2++;
+    return present2 === size2;
+  }
+  const record = actual;
+  let size = 0;
+  for (const key in wanted) {
+    const expected = wanted[key];
+    if (expected === void 0) continue;
+    size++;
+    if (!Object.hasOwn(record, key) || !deepEqual(record[key], expected, depth + 1, ignoreCase, now)) return false;
+  }
+  let present = 0;
+  for (const key in record) if (Object.hasOwn(record, key) && record[key] !== void 0) present++;
+  return present === size;
+}
+
+// src/operators.ts
+var NEVER = () => false;
+function lower(value) {
+  return value.toLowerCase();
+}
+function equalsTest(literal, ignoreCase, at, now) {
+  checkLiteral(literal, at);
+  if (literal === null) return (value) => value === null || value === void 0;
+  return equalsLiteral(literal, now, ignoreCase);
+}
+function inTest(list, ignoreCase, at, now) {
+  if (!Array.isArray(list)) throw new chunk74QKHM6Y_cjs.JqlError(`takes a list of values, not ${chunk74QKHM6Y_cjs.describe(list)}`, at);
+  if (list.length === 0) return NEVER;
+  const primitives = /* @__PURE__ */ new Set();
+  const complex = [];
+  let bigints;
+  let matchesMissing = false;
+  list.forEach((item, index) => {
+    checkLiteral(item, `${at}[${index}]`);
+    if (item === null) matchesMissing = true;
+    else if (typeof item === "object") complex.push(equalsLiteral(item, now, ignoreCase));
+    else {
+      primitives.add(ignoreCase && typeof item === "string" ? lower(item) : item);
+      const big = alsoBig(item);
+      if (big !== void 0) (bigints ??= /* @__PURE__ */ new Set()).add(big);
+    }
+  });
+  const fold = ignoreCase;
+  const whole = bigints;
+  return (value) => {
+    if (value === void 0 || value === null) return matchesMissing;
+    if (primitives.has(fold && typeof value === "string" ? lower(value) : value)) return true;
+    if (whole !== void 0 && typeof value === "bigint" && whole.has(value)) return true;
+    for (let i = 0; i < complex.length; i++) if (complex[i](value)) return true;
+    return false;
+  };
+}
+function orderTest(operator, bound, at, now) {
+  if (typeof bound === "number") {
+    if (Number.isNaN(bound)) throw new chunk74QKHM6Y_cjs.JqlError("NaN compares false with everything, so this would match nothing", at);
+    switch (operator) {
+      case "$gt":
+        return (value) => (typeof value === "number" || typeof value === "bigint") && value > bound;
+      case "$gte":
+        return (value) => (typeof value === "number" || typeof value === "bigint") && value >= bound;
+      case "$lt":
+        return (value) => (typeof value === "number" || typeof value === "bigint") && value < bound;
+      case "$lte":
+        return (value) => (typeof value === "number" || typeof value === "bigint") && value <= bound;
+    }
+  }
+  if (typeof bound === "string") {
+    switch (operator) {
+      case "$gt":
+        return (value) => typeof value === "string" && value > bound;
+      case "$gte":
+        return (value) => typeof value === "string" && value >= bound;
+      case "$lt":
+        return (value) => typeof value === "string" && value < bound;
+      case "$lte":
+        return (value) => typeof value === "string" && value <= bound;
+    }
+  }
+  if (chunk74QKHM6Y_cjs.isDateLiteral(bound)) {
+    const time = chunk74QKHM6Y_cjs.resolveDate(bound.$date, now);
+    if (Number.isNaN(time)) throw new chunk74QKHM6Y_cjs.JqlError(`${JSON.stringify(bound.$date)} is not a date, so every comparison with it would be false`, at);
+    switch (operator) {
+      case "$gt":
+        return (value) => value !== null && value !== void 0 && chunk74QKHM6Y_cjs.toTime(value) > time;
+      case "$gte":
+        return (value) => value !== null && value !== void 0 && chunk74QKHM6Y_cjs.toTime(value) >= time;
+      case "$lt":
+        return (value) => value !== null && value !== void 0 && chunk74QKHM6Y_cjs.toTime(value) < time;
+      case "$lte":
+        return (value) => value !== null && value !== void 0 && chunk74QKHM6Y_cjs.toTime(value) <= time;
+    }
+  }
+  throw new chunk74QKHM6Y_cjs.JqlError(`compares with a number, a string, a {"$date": \u2026} or a {"$field": \u2026}, not ${chunk74QKHM6Y_cjs.describe(bound)}`, at);
+}
+function stringTest(operator, operand, ignoreCase, at, maxGlobLength = Number.POSITIVE_INFINITY) {
+  const list = typeof operand === "string" ? [operand] : operand;
+  if (!Array.isArray(list)) throw new chunk74QKHM6Y_cjs.JqlError(`takes a string or a list of strings, not ${chunk74QKHM6Y_cjs.describe(operand)}`, at);
+  if (list.length === 0) return NEVER;
+  const wanted = list.map((item, index) => {
+    if (typeof item !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`takes strings, not ${chunk74QKHM6Y_cjs.describe(item)}`, `${at}[${index}]`);
+    return ignoreCase ? lower(item) : item;
+  });
+  if (operator === "$glob") {
+    for (const pattern of wanted) {
+      if (pattern.length > maxGlobLength) throw new chunk74QKHM6Y_cjs.JqlError(`the glob is ${pattern.length} characters, past the limit of ${maxGlobLength}`, at);
+    }
+    const globs = wanted.map(chunkITPY6VTV_cjs.compileGlob);
+    if (globs.length === 1) {
+      const only = globs[0];
+      return ignoreCase ? (value) => typeof value === "string" && only(lower(value)) : (value) => typeof value === "string" && only(value);
+    }
+    return (value) => {
+      if (typeof value !== "string") return false;
+      const actual = ignoreCase ? lower(value) : value;
+      for (let i = 0; i < globs.length; i++) if (globs[i](actual)) return true;
+      return false;
+    };
+  }
+  const one = (actual, value) => {
+    switch (operator) {
+      case "$contains":
+        return actual.includes(value);
+      case "$startsWith":
+        return actual.startsWith(value);
+      case "$endsWith":
+        return actual.endsWith(value);
+      case "$word":
+        return containsWord(actual, value);
+    }
+  };
+  if (wanted.length === 1) {
+    const only = wanted[0];
+    if (operator === "$contains") return ignoreCase ? (value) => typeof value === "string" && lower(value).includes(only) : (value) => typeof value === "string" && value.includes(only);
+    return (value) => typeof value === "string" && one(ignoreCase ? lower(value) : value, only);
+  }
+  return (value) => {
+    if (typeof value !== "string") return false;
+    const actual = ignoreCase ? lower(value) : value;
+    for (let i = 0; i < wanted.length; i++) if (one(actual, wanted[i])) return true;
+    return false;
+  };
+}
+var ALPHANUMERIC = /[\p{L}\p{N}]/u;
+function containsWord(actual, wanted) {
+  if (wanted === "") return false;
+  const characters = [...wanted];
+  const startsAlphanumeric = ALPHANUMERIC.test(characters[0]);
+  const endsAlphanumeric = ALPHANUMERIC.test(characters[characters.length - 1]);
+  let from = 0;
+  for (; ; ) {
+    const at = actual.indexOf(wanted, from);
+    if (at === -1) return false;
+    const end = at + wanted.length;
+    const startsClean = at === 0 || !startsAlphanumeric || !ALPHANUMERIC.test(before(actual, at));
+    const endsClean = end >= actual.length || !endsAlphanumeric || !ALPHANUMERIC.test(after(actual, end));
+    if (startsClean && endsClean) return true;
+    from = at + 1;
+  }
+}
+function before(text, at) {
+  const code = text.charCodeAt(at - 1);
+  return code >= 56320 && code <= 57343 && at >= 2 ? text.slice(at - 2, at) : text[at - 1];
+}
+function after(text, end) {
+  const code = text.charCodeAt(end);
+  return code >= 55296 && code <= 56319 ? text.slice(end, end + 2) : text[end];
+}
+var OPTION_FLAGS = /* @__PURE__ */ new Set(["i", "m", "s", "u"]);
+function parseOptions(options, at) {
+  if (typeof options !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`takes a string of flags such as "i", not ${chunk74QKHM6Y_cjs.describe(options)}`, at);
+  for (const flag of options) {
+    if (!OPTION_FLAGS.has(flag)) {
+      const why = flag === "g" || flag === "y" ? ": it makes a pattern stateful, so it would match on every other document" : "";
+      throw new chunk74QKHM6Y_cjs.JqlError(`"${flag}" is not a flag this language takes (i, m, s, u)${why}`, at);
+    }
+  }
+  if (new Set(options).size !== options.length) throw new chunk74QKHM6Y_cjs.JqlError(`"${options}" repeats a flag`, at);
+  return options;
+}
+function regexTest(pattern, flags, limits, at) {
+  if (!limits.allowRegex) throw new chunk74QKHM6Y_cjs.JqlError("patterns are turned off for this query; $contains, $startsWith, $endsWith and $word cover most of what one is for", at);
+  if (typeof pattern !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`takes the pattern as a string, not ${chunk74QKHM6Y_cjs.describe(pattern)}`, at);
+  if (pattern.length > limits.maxPatternLength) throw new chunk74QKHM6Y_cjs.JqlError(`the pattern is ${pattern.length} characters, past the limit of ${limits.maxPatternLength}`, at);
+  let expression;
+  try {
+    expression = new RegExp(pattern, flags);
+  } catch (error) {
+    throw new chunk74QKHM6Y_cjs.JqlError(`the pattern does not compile: ${error instanceof Error ? error.message : String(error)}`, at);
+  }
+  return (value) => typeof value === "string" && expression.test(value);
+}
+function typeTest(operand, at) {
+  const list = typeof operand === "string" ? [operand] : operand;
+  if (!Array.isArray(list) || list.length === 0) throw new chunk74QKHM6Y_cjs.JqlError(`takes a type name or a non-empty list of them, not ${chunk74QKHM6Y_cjs.describe(operand)}`, at);
+  const types = list.map((name, index) => {
+    if (typeof name !== "string" || !chunk74QKHM6Y_cjs.TYPE_NAMES.includes(name)) {
+      throw new chunk74QKHM6Y_cjs.JqlError(`${chunk74QKHM6Y_cjs.describe(name)} is not a type name (${chunk74QKHM6Y_cjs.TYPE_NAMES.join(", ")})${typeof name === "string" ? didYouMean(name, chunk74QKHM6Y_cjs.TYPE_NAMES) : ""}`, `${at}[${index}]`);
+    }
+    return name;
+  });
+  if (types.length === 1) {
+    const only = types[0];
+    return (value) => chunk74QKHM6Y_cjs.isOfType(value, only);
+  }
+  return (value) => types.some((type) => chunk74QKHM6Y_cjs.isOfType(value, type));
+}
+function modTest(operand, at) {
+  if (!Array.isArray(operand) || operand.length !== 2 || typeof operand[0] !== "number" || typeof operand[1] !== "number") {
+    throw new chunk74QKHM6Y_cjs.JqlError(`takes [divisor, remainder], not ${chunk74QKHM6Y_cjs.describe(operand)}`, at);
+  }
+  const [divisor, remainder] = operand;
+  if (divisor === 0 || !Number.isFinite(divisor)) throw new chunk74QKHM6Y_cjs.JqlError("a divisor of zero leaves no remainder to compare, so this would match nothing", at);
+  const big = Number.isInteger(divisor) ? BigInt(divisor) : void 0;
+  return (value) => {
+    if (typeof value === "number") return value % divisor === remainder;
+    if (typeof value === "bigint") return big !== void 0 && Number(value % big) === remainder;
+    return false;
+  };
+}
+function allTest(list, ignoreCase, at, now) {
+  if (!Array.isArray(list)) throw new chunk74QKHM6Y_cjs.JqlError(`takes a list of values, not ${chunk74QKHM6Y_cjs.describe(list)}`, at);
+  if (list.length === 0) return NEVER;
+  const tests = list.map((item, index) => {
+    if (chunk74QKHM6Y_cjs.isPlainObject(item) && Object.keys(item).some((key) => key.startsWith("$")) && !chunk74QKHM6Y_cjs.isDateLiteral(item)) {
+      throw new chunk74QKHM6Y_cjs.JqlError("takes values, not conditions; use $elemMatch inside $and for that", `${at}[${index}]`);
+    }
+    return equalsTest(item, ignoreCase, `${at}[${index}]`, now);
+  });
+  return (value) => {
+    for (const test of tests) {
+      if (test(value)) continue;
+      if (!Array.isArray(value)) return false;
+      let found = false;
+      for (let i = 0; i < value.length; i++) {
+        if (test(value[i])) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+    return true;
+  };
+}
+function orderOf(a, b) {
+  if ((typeof a === "number" || typeof a === "bigint") && (typeof b === "number" || typeof b === "bigint")) {
+    if (Number.isNaN(a) || Number.isNaN(b)) return void 0;
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
+  if (a instanceof Date && b instanceof Date) {
+    const left = a.getTime();
+    const right = b.getTime();
+    return Number.isNaN(left) || Number.isNaN(right) ? void 0 : left - right;
+  }
+  return void 0;
+}
+function checkLiteral(value, at, depth = 0) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new chunk74QKHM6Y_cjs.JqlError(`${String(value)} is not a JSON number`, at);
+    return;
+  }
+  if (depth > 64) throw new chunk74QKHM6Y_cjs.JqlError("the literal nests deeper than 64 levels", at);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => checkLiteral(item, `${at}[${index}]`, depth + 1));
+    return;
+  }
+  if (chunk74QKHM6Y_cjs.isPlainObject(value)) {
+    if (chunk74QKHM6Y_cjs.isFieldReference(value)) {
+      throw new chunk74QKHM6Y_cjs.JqlError(
+        `a {"$field": \u2026} reference compares with another field, which $eq, $ne and the ordering operators do; it is not a value that can be held here`,
+        at
+      );
+    }
+    if (chunk74QKHM6Y_cjs.isDateLiteral(value)) {
+      const date = value.$date;
+      if (Number.isNaN(chunk74QKHM6Y_cjs.resolveDate(date, 0))) {
+        const relative = chunk74QKHM6Y_cjs.isPlainObject(date) ? `; a relative date is {"$ago": "1h"} or {"$ahead": "1h"}, with a count and one of ${chunk74QKHM6Y_cjs.DURATION_UNITS.join(", ")}` : "";
+        throw new chunk74QKHM6Y_cjs.JqlError(`${JSON.stringify(date)} is not a date${relative}`, `${at}.$date`);
+      }
+      return;
+    }
+    for (const key in value) checkLiteral(value[key], `${at}.${key}`, depth + 1);
+    return;
+  }
+  const hint = value instanceof RegExp ? '; write {"$regex": "\u2026"} instead' : value instanceof Date ? '; write {"$date": "\u2026"} instead' : "";
+  throw new chunk74QKHM6Y_cjs.JqlError(`${chunk74QKHM6Y_cjs.describe(value)} is not JSON, so a query holding it could not be stored or sent${hint}`, at);
+}
+
+// src/core.ts
+var EXTENSION_NAME = /^\$x[A-Z][A-Za-z0-9]*$/;
+var ALWAYS = { test: () => true, cost: 0 };
+var NOTHING = { test: () => false, cost: 0 };
+var QUERY_OPERATORS = ["$and", "$or", "$nor", "$not", "$text", "$comment"];
+var FIELD_OPERATORS = [
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$exists",
+  "$type",
+  "$contains",
+  "$startsWith",
+  "$endsWith",
+  "$word",
+  "$glob",
+  "$regex",
+  "$options",
+  "$mod",
+  "$size",
+  "$length",
+  "$all",
+  "$elemMatch",
+  "$not"
+];
+var FIELD_OPERATOR_SET = new Set(FIELD_OPERATORS);
+var EVERY_OPERATOR = [.../* @__PURE__ */ new Set([...QUERY_OPERATORS, ...FIELD_OPERATORS])];
+var CASE_AWARE = /* @__PURE__ */ new Set(["$eq", "$ne", "$in", "$nin", "$all", "$contains", "$startsWith", "$endsWith", "$word", "$glob", "$regex"]);
+function compile(query, options = {}) {
+  if (typeof query === "function") return query;
+  const limits = options.limits === void 0 ? DEFAULT_LIMITS : { ...DEFAULT_LIMITS, ...options.limits };
+  const added = extensions(options.operators);
+  const context = {
+    vocabulary: chunkEJFHVGBC_cjs.checkVocabulary(options.vocabulary),
+    limits,
+    now: options.now === void 0 ? Date.now() : options.now(),
+    operators: added,
+    allowed: allowlist(limits.allowOperators, added),
+    nodes: 0
+  };
+  const { test } = compileQuery(query, context, "", 0);
+  if (test === ALWAYS.test) return () => true;
+  if (test === NOTHING.test) return () => false;
+  return test;
+}
+function matches(value, query, options) {
+  return compile(query, options)(value);
+}
+function validate(query, options) {
+  try {
+    return { valid: true, test: compile(query, options) };
+  } catch (error) {
+    if (error instanceof chunk74QKHM6Y_cjs.JqlError) return { valid: false, error };
+    throw error;
+  }
+}
+function untyped(query) {
+  return query;
+}
+function reachField(name, vocabulary, at) {
+  return resolveField(name, { vocabulary}, at).reach;
+}
+var ALWAYS_ALLOWED = /* @__PURE__ */ new Set(["$options", "$comment"]);
+var GATEABLE = /* @__PURE__ */ new Set([...FIELD_OPERATORS, ...QUERY_OPERATORS, "$field"]);
+function allowlist(names, added) {
+  if (names === "all") return void 0;
+  if (!Array.isArray(names)) throw new chunk74QKHM6Y_cjs.JqlError(`is a list of operator names or "all", not ${chunk74QKHM6Y_cjs.describe(names)}`, "limits.allowOperators");
+  const out = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (typeof name !== "string" || !GATEABLE.has(name) && !added.has(name)) {
+      throw new chunk74QKHM6Y_cjs.JqlError(`"${String(name)}" is not an operator, so allowing it allows nothing${typeof name === "string" ? didYouMean(name, [...GATEABLE]) : ""}`, "limits.allowOperators");
+    }
+    out.add(name);
+  }
+  return out;
+}
+function permit(key, context, at) {
+  const allowed = context.allowed;
+  if (allowed === void 0 || ALWAYS_ALLOWED.has(key) || allowed.has(key)) return;
+  const listed = [...allowed];
+  const shown = listed.length > 8 ? `${listed.slice(0, 8).join(", ")}, \u2026` : listed.join(", ");
+  throw new chunk74QKHM6Y_cjs.JqlError(`"${key}" is not an operator this query may use (${shown === "" ? "none" : shown})`, at);
+}
+var NO_EXTENSIONS = /* @__PURE__ */ new Map();
+function extensions(given) {
+  if (given === void 0 || given.length === 0) return NO_EXTENSIONS;
+  const out = /* @__PURE__ */ new Map();
+  for (const definition of given) {
+    if (!EXTENSION_NAME.test(definition.name)) {
+      throw new chunk74QKHM6Y_cjs.JqlError(`"${definition.name}" cannot name an added operator: the name is $x and a capital, such as "$xCidr", so a query that needs more than standard JQL says so`, "operators");
+    }
+    if (out.has(definition.name)) throw new chunk74QKHM6Y_cjs.JqlError(`"${definition.name}" is given twice, and the two could not both be it`, "operators");
+    if (typeof definition.compile !== "function") throw new chunk74QKHM6Y_cjs.JqlError(`"${definition.name}" has no compile function, so there is nothing for it to do`, "operators");
+    out.set(definition.name, definition);
+  }
+  return out;
+}
+function count(context, at) {
+  context.nodes++;
+  if (context.nodes > context.limits.maxNodes) throw new chunk74QKHM6Y_cjs.JqlError(`the query holds more than ${context.limits.maxNodes} fields and operators`, at);
+}
+function join(at, key) {
+  return at === "" ? key : `${at}.${key}`;
+}
+function compileQuery(query, context, at, depth) {
+  if (depth > context.limits.maxDepth) throw new chunk74QKHM6Y_cjs.JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);
+  if (!chunk74QKHM6Y_cjs.isPlainObject(query)) throw new chunk74QKHM6Y_cjs.JqlError(`a query is an object, not ${chunk74QKHM6Y_cjs.describe(query)}`, at);
+  const parts = [];
+  let self;
+  for (const key in query) {
+    const value = query[key];
+    const here = join(at, key);
+    if (value === void 0) {
+      throw new chunk74QKHM6Y_cjs.JqlError("the value is undefined; JSON has no undefined, and a condition on nothing would match everything", here);
+    }
+    count(context, here);
+    if (!key.startsWith("$")) {
+      parts.push(compileField(resolveField(key, context, here), value, context, here, depth));
+      continue;
+    }
+    permit(key, context, here);
+    switch (key) {
+      case "$and":
+        parts.push(allOf(queryList(value, context, here, depth)));
+        break;
+      case "$or":
+        parts.push(anyOf(queryList(value, context, here, depth)));
+        break;
+      case "$nor":
+        parts.push(negate(anyOf(queryList(value, context, here, depth))));
+        break;
+      case "$not":
+        parts.push(negate(compileQuery(value, context, here, depth + 1)));
+        break;
+      case "$text":
+        parts.push(compileText(value, context, here));
+        break;
+      case "$comment":
+        if (typeof value !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a comment is a string, not ${chunk74QKHM6Y_cjs.describe(value)}`, here);
+        break;
+      default:
+        if (!FIELD_OPERATOR_SET.has(key)) throw new chunk74QKHM6Y_cjs.JqlError(`"${key}" is not an operator${didYouMean(key, EVERY_OPERATOR)}`, here);
+        self ??= {};
+        self[key] = value;
+    }
+  }
+  if (self !== void 0) parts.push(compileCondition(SELF, self, context, at, depth));
+  return allOf(parts);
+}
+function queryList(value, context, at, depth) {
+  if (!Array.isArray(value)) throw new chunk74QKHM6Y_cjs.JqlError(`takes a list of queries, not ${chunk74QKHM6Y_cjs.describe(value)}`, at);
+  return value.map((item, index) => compileQuery(item, context, `${at}[${index}]`, depth + 1));
+}
+var SELF = { read: readSelf, probe: void 0, reach: (document, test) => test(document), key: void 0, cost: 0 };
+function resolveField(name, context, at) {
+  const vocabulary = context.vocabulary;
+  if (vocabulary !== void 0) {
+    const direct = vocabulary.lookup.get(name.toLowerCase());
+    if (direct !== void 0) return fieldOf(direct, [], at);
+    const dot = name.indexOf(".");
+    if (dot > 0) {
+      const head = vocabulary.lookup.get(name.slice(0, dot).toLowerCase());
+      if (head !== void 0) {
+        const rest = splitPath(name.slice(dot + 1));
+        if (typeof rest === "string") throw new chunk74QKHM6Y_cjs.JqlError(rest, at);
+        return fieldOf(head, rest, at);
+      }
+    }
+    if (vocabulary.strict) throw new chunk74QKHM6Y_cjs.JqlError(`"${name}" is not a field here${didYouMean(name, vocabulary.names)}`, at);
+  }
+  const keys = splitPath(name);
+  if (typeof keys === "string") throw new chunk74QKHM6Y_cjs.JqlError(keys, at);
+  return pathField(keys);
+}
+function fieldOf(field, rest, at) {
+  if (field.get !== void 0) {
+    const get = field.get;
+    if (rest.length === 0) return { read: get, probe: void 0, reach: (document, test) => test(get(document)), key: void 0, cost: 3 };
+    return { read: void 0, probe: probeFrom(get, rest), reach: reachFrom(get, rest), key: void 0, cost: 3 + rest.length };
+  }
+  const keys = splitPath(field.path);
+  if (typeof keys === "string") throw new chunk74QKHM6Y_cjs.JqlError(keys, at);
+  return pathField([...keys, ...rest]);
+}
+function pathField(keys) {
+  if (keys.length === 1) {
+    const key = keys[0];
+    return { read: void 0, probe: probePath(keys), reach: reachPath(keys), key, cost: 0 };
+  }
+  return { read: void 0, probe: probePath(keys), reach: reachPath(keys), key: void 0, cost: keys.length };
+}
+function compileField(field, value, context, at, depth) {
+  if (chunk74QKHM6Y_cjs.isFieldReference(value)) {
+    permit("$field", context, at);
+    permit("$eq", context, at);
+    return compareFields(field, "$eq", value.$field, false, context, at);
+  }
+  if (chunk74QKHM6Y_cjs.isPlainObject(value) && !chunk74QKHM6Y_cjs.isDateLiteral(value)) {
+    let operators = 0;
+    let names = 0;
+    for (const key in value) {
+      if (key.startsWith("$")) operators++;
+      else names++;
+    }
+    if (operators > 0 && names > 0) {
+      throw new chunk74QKHM6Y_cjs.JqlError("mixes operators with field names; an object here is either a condition ({ $gt: 1 }) or a value to compare with ({ a: 1 }), not both", at);
+    }
+    if (operators > 0) return compileCondition(field, value, context, at, depth + 1);
+  }
+  permit("$eq", context, at);
+  return equality(field, value, false, at, context.now);
+}
+function compileCondition(field, condition, context, at, depth) {
+  const { values, whole } = conditionParts(field, condition, context, at, depth);
+  return combine(field, values, whole);
+}
+function combine(field, values, whole) {
+  const parts = [...whole];
+  if (values.length > 0) {
+    const cost = values.reduce((sum, value) => sum + value.cost, 0);
+    if (field.read !== void 0) {
+      const only = values.length === 1 ? values[0] : void 0;
+      parts.push(only !== void 0 && only.any !== void 0 ? holdsAny(field, only.any, only.negated, cost) : holds(field, allOfValues(values), cost));
+    } else {
+      const separate = allOf(values.map((value) => value.negated ? negate(holds(field, value.test, value.cost)) : holds(field, value.test, value.cost)));
+      const probe = field.probe;
+      if (probe === void 0) parts.push(separate);
+      else {
+        const fused = allOfValues(values);
+        const fallback = separate.test;
+        parts.push({ test: (document) => {
+          const value = probe(document);
+          return value === FANOUT ? fallback(document) : fused(value);
+        }, cost: separate.cost });
+      }
+    }
+  }
+  return allOf(parts);
+}
+function conditionParts(field, condition, context, at, depth) {
+  if (depth > context.limits.maxDepth) throw new chunk74QKHM6Y_cjs.JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);
+  let flags = "";
+  if (condition.$options !== void 0) {
+    flags = parseOptions(condition.$options, join(at, "$options"));
+    const usesCase = Object.keys(condition).some((key) => CASE_AWARE.has(key));
+    if (!usesCase) throw new chunk74QKHM6Y_cjs.JqlError("$options has nothing to apply to: it changes $regex and the equality and string operators beside it", join(at, "$options"));
+    if (/[msu]/.test(flags) && condition.$regex === void 0) throw new chunk74QKHM6Y_cjs.JqlError(`the flags "${flags.replace("i", "")}" only mean something to $regex, and there is none here`, join(at, "$options"));
+  }
+  const ignoreCase = flags.includes("i");
+  const values = [];
+  const whole = [];
+  const add = (test, cost, negated = false) => {
+    values.push({ test, cost, negated, any: void 0 });
+  };
+  const addAny = (test, cost, negated = false) => {
+    values.push({ test: elementwise(test), cost, negated, any: test });
+  };
+  for (const key in condition) {
+    const operand = condition[key];
+    const here = join(at, key);
+    if (operand === void 0) throw new chunk74QKHM6Y_cjs.JqlError("the value is undefined; JSON has no undefined, and a condition on nothing would match everything", here);
+    count(context, here);
+    permit(key, context, here);
+    switch (key) {
+      case "$options":
+        break;
+      case "$eq":
+      case "$ne": {
+        const negated = key === "$ne";
+        const reference = referencePath(operand, here);
+        if (reference !== void 0) {
+          permit("$field", context, here);
+          whole.push(compareFields(field, "$eq", reference, negated, context, here));
+          break;
+        }
+        add(equalsValue(operand, ignoreCase, here, context.now), operand !== null && typeof operand === "object" ? 3 : 0, negated);
+        break;
+      }
+      case "$gt":
+      case "$gte":
+      case "$lt":
+      case "$lte":
+        {
+          const reference = referencePath(operand, here);
+          if (reference !== void 0) {
+            permit("$field", context, here);
+            whole.push(compareFields(field, key, reference, false, context, here));
+            break;
+          }
+          addAny(orderTest(key, operand, here, context.now), 1);
+        }
+        break;
+      case "$in":
+        addAny(inTest(operand, ignoreCase, here, context.now), 1);
+        break;
+      case "$nin":
+        addAny(inTest(operand, ignoreCase, here, context.now), 1, true);
+        break;
+      case "$exists":
+        if (typeof operand !== "boolean") throw new chunk74QKHM6Y_cjs.JqlError(`takes true or false, not ${chunk74QKHM6Y_cjs.describe(operand)}`, here);
+        add(isPresent, 0, !operand);
+        break;
+      case "$type":
+        addAny(typeTest(operand, here), 1);
+        break;
+      case "$contains":
+      case "$startsWith":
+      case "$endsWith":
+      case "$word":
+      case "$glob":
+        addAny(stringTest(key, operand, ignoreCase, here, context.limits.maxGlobLength), key === "$word" || key === "$glob" ? 4 : 2);
+        break;
+      case "$regex":
+        addAny(regexTest(operand, flags, context.limits, here), 5);
+        break;
+      case "$mod":
+        addAny(modTest(operand, here), 1);
+        break;
+      case "$size":
+        add(sizeTest(operand, context, here, depth, "array"), 1);
+        break;
+      case "$length":
+        add(sizeTest(operand, context, here, depth, "anything with a length"), 1);
+        break;
+      case "$all":
+        add(allTest(operand, ignoreCase, here, context.now), 4);
+        break;
+      case "$elemMatch": {
+        if (!chunk74QKHM6Y_cjs.isPlainObject(operand)) throw new chunk74QKHM6Y_cjs.JqlError(`takes a query for one element, not ${chunk74QKHM6Y_cjs.describe(operand)}`, here);
+        const element = compileQuery(operand, context, here, depth + 1);
+        const test = element.test;
+        add((value) => {
+          if (!Array.isArray(value)) return false;
+          for (let i = 0; i < value.length; i++) if (test(value[i])) return true;
+          return false;
+        }, 4 + element.cost);
+        break;
+      }
+      case "$not": {
+        if (!chunk74QKHM6Y_cjs.isPlainObject(operand) || chunk74QKHM6Y_cjs.isDateLiteral(operand) || !Object.keys(operand).every((name) => name.startsWith("$"))) {
+          throw new chunk74QKHM6Y_cjs.JqlError(`takes a condition such as { "$gt": 5 }, not ${chunk74QKHM6Y_cjs.describe(operand)}; to negate a value, use $ne`, here);
+        }
+        const inner = conditionParts(field, operand, context, here, depth + 1);
+        if (field.read !== void 0 && inner.whole.length === 0) {
+          add(allOfValues(inner.values), inner.values.reduce((sum, value) => sum + value.cost, 0), true);
+          break;
+        }
+        whole.push(negate(combine(field, inner.values, inner.whole)));
+        break;
+      }
+      default: {
+        const extension = context.operators.get(key);
+        if (extension !== void 0) {
+          const test = extension.compile(operand, here);
+          if (typeof test !== "function") throw new chunk74QKHM6Y_cjs.JqlError(`"${key}" did not build a test, so there is nothing to run`, here);
+          const cost = extension.cost ?? 4;
+          if (extension.elementwise === false) add(test, cost);
+          else addAny(test, cost);
+          break;
+        }
+        const reason = QUERY_OPERATORS.includes(key) ? `"${key}" combines whole queries, so it belongs beside field names rather than inside a field's condition` : EXTENSION_NAME.test(key) ? `"${key}" is an added operator, and this query was compiled without it; pass it in \`operators\`` : `"${key}" is not an operator${didYouMean(key, [...FIELD_OPERATORS, ...context.operators.keys()])}`;
+        throw new chunk74QKHM6Y_cjs.JqlError(reason, here);
+      }
+    }
+  }
+  return { values, whole };
+}
+function allOfValues(values) {
+  const tests = [...values].sort((a, b) => a.cost - b.cost).map(({ test, negated }) => negated ? (value) => !test(value) : test);
+  if (tests.length === 0) return () => true;
+  if (tests.length === 1) return tests[0];
+  if (tests.length === 2) {
+    const [a, b] = tests;
+    return (value) => a(value) && b(value);
+  }
+  return (value) => {
+    for (let i = 0; i < tests.length; i++) if (!tests[i](value)) return false;
+    return true;
+  };
+}
+var isPresent = (value) => value !== void 0;
+function elementwise(test) {
+  return (value) => {
+    if (test(value)) return true;
+    if (!Array.isArray(value)) return false;
+    for (let i = 0; i < value.length; i++) if (test(value[i])) return true;
+    return false;
+  };
+}
+function holds(field, test, cost) {
+  const key = field.key;
+  if (key !== void 0) {
+    const reach2 = field.reach;
+    const plain = !needsGuard(key);
+    return {
+      test: (document) => {
+        if (document === null || typeof document !== "object") return test(void 0);
+        if (Array.isArray(document)) return reach2(document, test);
+        return test(plain && document.__proto__ === PLAIN ? document[key] : readOwn(document, key));
+      },
+      cost: field.cost + cost
+    };
+  }
+  const read = field.read;
+  if (read === readSelf) return { test, cost: field.cost + cost };
+  if (read !== void 0) return { test: (document) => test(read(document)), cost: field.cost + cost };
+  const reach = field.reach;
+  const probe = field.probe;
+  if (probe !== void 0) {
+    return {
+      test: (document) => {
+        const value = probe(document);
+        return value === FANOUT ? reach(document, test) : test(value);
+      },
+      cost: field.cost + cost
+    };
+  }
+  return { test: (document) => reach(document, test), cost: field.cost + cost };
+}
+function holdsAny(field, test, negated, cost) {
+  const key = field.key;
+  if (key === void 0) {
+    const read = field.read;
+    const single = (value) => {
+      if (test(value)) return true;
+      if (!Array.isArray(value)) return false;
+      for (let i = 0; i < value.length; i++) if (test(value[i])) return true;
+      return false;
+    };
+    return { test: negated ? (document) => !single(read(document)) : (document) => single(read(document)), cost: field.cost + cost };
+  }
+  const reach = field.reach;
+  const plain = !needsGuard(key);
+  const any = (value) => {
+    if (test(value)) return true;
+    if (!Array.isArray(value)) return false;
+    for (let i = 0; i < value.length; i++) if (test(value[i])) return true;
+    return false;
+  };
+  const hit = (document) => {
+    if (document === null || typeof document !== "object") return test(void 0);
+    if (Array.isArray(document)) return reach(document, any);
+    return any(plain && document.__proto__ === PLAIN ? document[key] : readOwn(document, key));
+  };
+  return { test: negated ? (document) => !hit(document) : hit, cost: field.cost + cost };
+}
+function equalsValue(literal, ignoreCase, at, now) {
+  if (!ignoreCase && (typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean")) {
+    checkLiteral(literal, at);
+    const wanted = literal;
+    const big = alsoBig(literal);
+    if (big !== void 0) return (value) => value === wanted || value === big || Array.isArray(value) && (value.includes(wanted) || value.includes(big));
+    return (value) => value === wanted || Array.isArray(value) && value.includes(wanted);
+  }
+  return elementwise(equalsTest(literal, ignoreCase, at, now));
+}
+function equality(field, literal, ignoreCase, at, now) {
+  const key = field.key;
+  if (key !== void 0 && !ignoreCase && (typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean")) {
+    checkLiteral(literal, at);
+    const wanted = literal;
+    const reach = field.reach;
+    const plain = !needsGuard(key);
+    const test = equalsValue(literal, false, at, now);
+    const big = alsoBig(literal);
+    if (big !== void 0) {
+      return {
+        test: (document) => {
+          if (document === null || typeof document !== "object") return false;
+          if (Array.isArray(document)) return reach(document, test);
+          const value = plain && document.__proto__ === PLAIN ? document[key] : readOwn(document, key);
+          return value === wanted || value === big || Array.isArray(value) && (value.includes(wanted) || value.includes(big));
+        },
+        cost: 0
+      };
+    }
+    return {
+      test: (document) => {
+        if (document === null || typeof document !== "object") return false;
+        if (Array.isArray(document)) return reach(document, test);
+        const value = plain && document.__proto__ === PLAIN ? document[key] : readOwn(document, key);
+        return value === wanted || Array.isArray(value) && value.includes(wanted);
+      },
+      cost: 0
+    };
+  }
+  const probe = field.probe;
+  if (probe !== void 0 && !ignoreCase && (typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean")) {
+    checkLiteral(literal, at);
+    const wanted = literal;
+    const test = equalsValue(literal, false, at, now);
+    const reach = field.reach;
+    const big = alsoBig(literal);
+    if (big !== void 0) {
+      return {
+        test: (document) => {
+          const value = probe(document);
+          if (value === wanted || value === big) return true;
+          if (value === FANOUT) return reach(document, test);
+          return Array.isArray(value) && (value.includes(wanted) || value.includes(big));
+        },
+        cost: field.cost
+      };
+    }
+    return {
+      test: (document) => {
+        const value = probe(document);
+        if (value === wanted) return true;
+        if (value === FANOUT) return reach(document, test);
+        return Array.isArray(value) && value.includes(wanted);
+      },
+      cost: field.cost
+    };
+  }
+  return holds(field, equalsValue(literal, ignoreCase, at, now), literal !== null && typeof literal === "object" ? 3 : 0);
+}
+function sizeTest(operand, context, at, depth, measures) {
+  const strings = measures !== "array";
+  let length;
+  if (typeof operand === "number") {
+    if (!Number.isInteger(operand) || operand < 0) throw new chunk74QKHM6Y_cjs.JqlError(`a length is a whole number, not ${operand}`, at);
+    length = (size) => size === operand;
+  } else if (chunk74QKHM6Y_cjs.isPlainObject(operand)) {
+    length = compileCondition(SELF, operand, context, at, depth + 1).test;
+  } else throw new chunk74QKHM6Y_cjs.JqlError(`takes a number or a condition on one, not ${chunk74QKHM6Y_cjs.describe(operand)}`, at);
+  if (strings) return (value) => (typeof value === "string" || Array.isArray(value)) && length(value.length);
+  return (value) => Array.isArray(value) && length(value.length);
+}
+function compareFields(field, operator, path, negated, context, at) {
+  const other = resolveField(path, context, at);
+  const compare = comparer(operator);
+  const leftRead = field.read;
+  const rightRead = other.read;
+  let holdsPair;
+  if (leftRead !== void 0 && rightRead !== void 0) {
+    holdsPair = (document) => eachOf(leftRead(document), (one) => eachOf(rightRead(document), (two) => compare(one, two)));
+  } else {
+    const left = field.reach;
+    const right = other.reach;
+    holdsPair = (document) => left(document, (one) => eachOf(one, (a) => right(document, (two) => eachOf(two, (b) => compare(a, b)))));
+  }
+  return { test: negated ? (document) => !holdsPair(document) : holdsPair, cost: field.cost + other.cost + 4 };
+}
+function comparer(operator) {
+  if (operator === "$eq") return (a, b) => a !== void 0 && b !== void 0 && valuesEqual(a, b);
+  return (a, b) => {
+    if (a === void 0 || b === void 0) return false;
+    const order = orderOf(a, b);
+    if (order === void 0) return false;
+    switch (operator) {
+      case "$gt":
+        return order > 0;
+      case "$gte":
+        return order >= 0;
+      case "$lt":
+        return order < 0;
+      default:
+        return order <= 0;
+    }
+  };
+}
+function referencePath(operand, at) {
+  if (!chunk74QKHM6Y_cjs.isPlainObject(operand) || !("$field" in operand)) return void 0;
+  if (typeof operand.$field !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a {"$field": \u2026} reference takes the path as a string, not ${chunk74QKHM6Y_cjs.describe(operand.$field)}`, at);
+  const beside = Object.keys(operand).filter((key) => key !== "$field");
+  if (beside.length > 0) throw new chunk74QKHM6Y_cjs.JqlError(`a {"$field": \u2026} reference holds nothing but the path, and "${beside[0]}" is beside it`, at);
+  return operand.$field;
+}
+function eachOf(value, test) {
+  if (test(value)) return true;
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i++) if (test(value[i])) return true;
+  return false;
+}
+function compileText(value, context, at) {
+  let search2;
+  let fields;
+  let caseSensitive = false;
+  if (typeof value === "string") search2 = value;
+  else if (chunk74QKHM6Y_cjs.isPlainObject(value)) {
+    for (const key in value) {
+      if (key !== "$search" && key !== "$fields" && key !== "$caseSensitive") {
+        throw new chunk74QKHM6Y_cjs.JqlError(`"${key}" is not part of a text search ($search, $fields, $caseSensitive)${didYouMean(key, ["$search", "$fields", "$caseSensitive"])}`, join(at, key));
+      }
+    }
+    search2 = value.$search;
+    fields = value.$fields;
+    caseSensitive = "$caseSensitive" in value ? value.$caseSensitive : false;
+  } else throw new chunk74QKHM6Y_cjs.JqlError(`takes a phrase or { "$search": \u2026 }, not ${chunk74QKHM6Y_cjs.describe(value)}`, at);
+  if (typeof search2 !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`the phrase is a string, not ${chunk74QKHM6Y_cjs.describe(search2)}`, join(at, "$search"));
+  if (typeof caseSensitive !== "boolean") throw new chunk74QKHM6Y_cjs.JqlError(`takes true or false, not ${chunk74QKHM6Y_cjs.describe(caseSensitive)}`, join(at, "$caseSensitive"));
+  const names = fields === void 0 ? context.vocabulary?.text : fields;
+  const reaches = names === void 0 ? void 0 : textFields(names, context, at);
+  const needle = caseSensitive ? search2 : search2.toLowerCase();
+  if (needle === "") return ALWAYS;
+  const found = caseSensitive ? (text) => text.includes(needle) : (text) => text.toLowerCase().includes(needle);
+  const numeric = /\d/.test(needle);
+  const maxDepth = context.limits.maxTextDepth;
+  const inValue = (item) => containsText(item, found, numeric, maxDepth);
+  if (reaches === void 0) return { test: inValue, cost: 20 };
+  return {
+    test: (document) => {
+      for (let i = 0; i < reaches.length; i++) if (reaches[i](document, inValue)) return true;
+      return false;
+    },
+    cost: 6 + reaches.length * 2
+  };
+}
+function textFields(names, context, at) {
+  if (!Array.isArray(names) || names.length === 0) throw new chunk74QKHM6Y_cjs.JqlError(`takes a non-empty list of field names, not ${chunk74QKHM6Y_cjs.describe(names)}`, join(at, "$fields"));
+  return names.map((name, index) => {
+    if (typeof name !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a field name is a string, not ${chunk74QKHM6Y_cjs.describe(name)}`, `${join(at, "$fields")}[${index}]`);
+    return resolveField(name, context, `${join(at, "$fields")}[${index}]`).reach;
+  });
+}
+function containsText(value, found, numeric, depth) {
+  if (typeof value === "string") return found(value);
+  if (typeof value === "number" || typeof value === "bigint") return numeric && found(String(value));
+  if (value === null || typeof value !== "object" || depth <= 0 || value instanceof Date) return false;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) if (containsText(value[i], found, numeric, depth - 1)) return true;
+    return false;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    for (const item of value.values()) if (containsText(item, found, numeric, depth - 1)) return true;
+    return false;
+  }
+  const record = value;
+  for (const key in record) if (Object.hasOwn(record, key) && containsText(record[key], found, numeric, depth - 1)) return true;
+  return false;
+}
+function allOf(parts) {
+  const real = parts.filter((part) => part !== ALWAYS);
+  if (real.includes(NOTHING)) return NOTHING;
+  if (real.length === 0) return ALWAYS;
+  if (real.length === 1) return real[0];
+  real.sort((a, b) => a.cost - b.cost);
+  const cost = real.reduce((sum, part) => sum + part.cost, 0);
+  const tests = real.map((part) => part.test);
+  if (tests.length === 2) {
+    const [a, b] = tests;
+    return { test: (document) => a(document) && b(document), cost };
+  }
+  if (tests.length === 3) {
+    const [a, b, c] = tests;
+    return { test: (document) => a(document) && b(document) && c(document), cost };
+  }
+  return {
+    test: (document) => {
+      for (let i = 0; i < tests.length; i++) if (!tests[i](document)) return false;
+      return true;
+    },
+    cost
+  };
+}
+function anyOf(parts) {
+  const real = parts.filter((part) => part !== NOTHING);
+  if (real.includes(ALWAYS)) return ALWAYS;
+  if (real.length === 0) return NOTHING;
+  if (real.length === 1) return real[0];
+  real.sort((a, b) => a.cost - b.cost);
+  const cost = real.reduce((sum, part) => sum + part.cost, 0);
+  const tests = real.map((part) => part.test);
+  if (tests.length === 2) {
+    const [a, b] = tests;
+    return { test: (document) => a(document) || b(document), cost };
+  }
+  return {
+    test: (document) => {
+      for (let i = 0; i < tests.length; i++) if (tests[i](document)) return true;
+      return false;
+    },
+    cost
+  };
+}
+function negate(part) {
+  if (part === ALWAYS) return NOTHING;
+  if (part === NOTHING) return ALWAYS;
+  const test = part.test;
+  return { test: (document) => !test(document), cost: part.cost };
+}
+
+// src/internal/record.ts
+function setField(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+    return;
+  }
+  target[key] = value;
+}
+
+// src/collections.ts
+function walk2(source, visit) {
+  if (Array.isArray(source)) {
+    for (let i = 0; i < source.length; i++) if (visit(source[i])) return i;
+    return -1;
+  }
+  if (source instanceof Map) {
+    let i = 0;
+    for (const item of source.values()) {
+      if (visit(item)) return i;
+      i++;
+    }
+    return -1;
+  }
+  if (typeof source[Symbol.iterator] === "function") {
+    let i = 0;
+    for (const item of source) {
+      if (visit(item)) return i;
+      i++;
+    }
+    return -1;
+  }
+  const list = source;
+  for (let i = 0; i < list.length; i++) if (visit(list[i])) return i;
+  return -1;
+}
+function find(source, query, options) {
+  const test = compile(query, options);
+  let found;
+  walk2(source, (item) => {
+    if (!test(item)) return false;
+    found = item;
+    return true;
+  });
+  return found;
+}
+function findIndex(source, query, options) {
+  return walk2(source, compile(query, options));
+}
+function filter(source, query, options) {
+  const test = compile(query, options);
+  const out = [];
+  walk2(source, (item) => {
+    if (test(item)) out.push(item);
+    return false;
+  });
+  return out;
+}
+function count2(source, query, options) {
+  const test = compile(query, options);
+  let total = 0;
+  walk2(source, (item) => {
+    if (test(item)) total++;
+    return false;
+  });
+  return total;
+}
+function some(source, query, options) {
+  return walk2(source, compile(query, options)) !== -1;
+}
+function every(source, query, options) {
+  const test = compile(query, options);
+  return walk2(source, (item) => !test(item)) === -1;
+}
+function partition(source, query, options) {
+  const test = compile(query, options);
+  const yes = [];
+  const no = [];
+  walk2(source, (item) => {
+    (test(item) ? yes : no).push(item);
+    return false;
+  });
+  return [yes, no];
+}
+function filterMap(source, query, options) {
+  const test = compile(query, options);
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of source) if (test(value)) out.set(key, value);
+  return out;
+}
+function filterRecord(source, query, options) {
+  const test = compile(query, options);
+  const out = {};
+  for (const key of Object.keys(source)) {
+    const value = source[key];
+    if (test(value)) setField(out, key, value);
+  }
+  return out;
+}
+function findEntry(source, query, options) {
+  const test = compile(query, options);
+  if (source instanceof Map) {
+    for (const [key, value] of source) if (test(value)) return [key, value];
+    return void 0;
+  }
+  const record = source;
+  for (const key of Object.keys(record)) {
+    const value = record[key];
+    if (test(value)) return [key, value];
+  }
+  return void 0;
+}
+
+// src/internal/order.ts
+function rank(value) {
+  if (value === void 0 || value === null) return 0;
+  switch (typeof value) {
+    case "number":
+    case "bigint":
+      return Number.isNaN(value) ? 0 : 1;
+    case "string":
+      return 2;
+    case "boolean":
+      return 4;
+    default:
+      return value instanceof Date ? 5 : 3;
+  }
+}
+function compareValues(a, b) {
+  const ra = rank(a);
+  const rb = rank(b);
+  if (ra !== rb) return ra - rb;
+  switch (ra) {
+    case 1:
+    case 2:
+      return a < b ? -1 : a > b ? 1 : 0;
+    case 4:
+      return a === b ? 0 : a ? 1 : -1;
+    case 5:
+      return a.getTime() - b.getTime();
+    default:
+      return 0;
+  }
+}
+function sortValue(values, descending, depth = 0) {
+  let best;
+  let first = true;
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      if (value.length === 0 || depth >= 16) continue;
+      const inner = sortValue(value, descending, depth + 1);
+      if (first || (descending ? compareValues(inner, best) > 0 : compareValues(inner, best) < 0)) best = inner;
+      first = false;
+      continue;
+    }
+    if (first || (descending ? compareValues(value, best) > 0 : compareValues(value, best) < 0)) best = value;
+    first = false;
+  }
+  return best;
+}
+
+// src/search.ts
+var REQUEST_KEYS = ["where", "sort", "skip", "limit", "fields", "omit"];
+function search(source, request = {}, options = {}) {
+  const plan = planRequest(request, options);
+  const collect = plan.collect();
+  const test = plan.test;
+  each(source, (item, index) => {
+    if (test !== void 0 && !test(item)) return false;
+    return collect.offer(item, index);
+  });
+  return plan.shape(collect.finish());
+}
+function planRequest(request, options) {
+  if (!chunk74QKHM6Y_cjs.isPlainObject(request)) throw new chunk74QKHM6Y_cjs.JqlError(`a request is an object, not ${chunk74QKHM6Y_cjs.describe(request)}`);
+  for (const key of Object.keys(request)) {
+    if (!REQUEST_KEYS.includes(key)) throw new chunk74QKHM6Y_cjs.JqlError(`"${key}" is not part of a request (${REQUEST_KEYS.join(", ")})${didYouMean(key, REQUEST_KEYS)}`, key);
+  }
+  const vocabulary = chunkEJFHVGBC_cjs.checkVocabulary(options.vocabulary);
+  const test = request.where === void 0 ? void 0 : compile(request.where, options);
+  const skip = count3(request.skip, "skip") ?? 0;
+  const limit = count3(request.limit, "limit");
+  const keys = sortKeys(request.sort, vocabulary);
+  const project = request.fields === void 0 ? void 0 : projector(request.fields, vocabulary);
+  const drop = request.omit === void 0 ? void 0 : redactor(request.omit, vocabulary);
+  return {
+    collect: () => collector(keys, skip, limit),
+    test,
+    shape: (items) => {
+      const projected = project === void 0 ? items : items.map(project);
+      return drop === void 0 ? projected : projected.map(drop);
+    }
+  };
+}
+function collector(keys, skip, limit) {
+  return keys.length === 0 ? inOrder(skip, limit) : ranked(keys, skip, limit);
+}
+function count3(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new chunk74QKHM6Y_cjs.JqlError(`is a whole number of items, zero or more, not ${chunk74QKHM6Y_cjs.describe(value)}`, name);
+  }
+  return value;
+}
+function sortKeys(sort, vocabulary) {
+  if (sort === void 0) return [];
+  if (!chunk74QKHM6Y_cjs.isPlainObject(sort)) throw new chunk74QKHM6Y_cjs.JqlError(`is an object of field names to directions, not ${chunk74QKHM6Y_cjs.describe(sort)}`, "sort");
+  return Object.keys(sort).map((name) => {
+    const direction = sort[name];
+    const at = `sort.${name}`;
+    if (direction !== 1 && direction !== -1 && direction !== "asc" && direction !== "desc") {
+      throw new chunk74QKHM6Y_cjs.JqlError(`a direction is 1, -1, "asc" or "desc", not ${chunk74QKHM6Y_cjs.describe(direction)}`, at);
+    }
+    return { reach: reachField(name, vocabulary, at), descending: direction === -1 || direction === "desc" };
+  });
+}
+function each(source, visit) {
+  if (Array.isArray(source)) {
+    for (let i2 = 0; i2 < source.length; i2++) if (visit(source[i2], i2)) return;
+    return;
+  }
+  const iterable = source instanceof Map ? source.values() : typeof source[Symbol.iterator] === "function" ? source : void 0;
+  if (iterable === void 0) {
+    const list = source;
+    for (let i2 = 0; i2 < list.length; i2++) if (visit(list[i2], i2)) return;
+    return;
+  }
+  let i = 0;
+  for (const item of iterable) if (visit(item, i++)) return;
+}
+function inOrder(skip, limit) {
+  const out = [];
+  let passed = 0;
+  return {
+    offer(item) {
+      if (limit === 0) return true;
+      if (passed < skip) {
+        passed++;
+        return false;
+      }
+      out.push(item);
+      return limit !== void 0 && out.length >= limit;
+    },
+    finish: () => out
+  };
+}
+function ranked(keys, skip, limit) {
+  const compare = (a, b) => {
+    for (let i = 0; i < keys.length; i++) {
+      const order = compareValues(a.keys[i], b.keys[i]);
+      if (order !== 0) return keys[i].descending ? -order : order;
+    }
+    return a.index - b.index;
+  };
+  const keep = limit === void 0 ? Number.POSITIVE_INFINITY : skip + limit;
+  const heap = [];
+  return {
+    offer(item, index) {
+      if (limit === 0) return true;
+      const entry = { item, keys: keys.map((key) => keyOf(item, key)), index };
+      if (heap.length < keep) {
+        heap.push(entry);
+        if (keep !== Number.POSITIVE_INFINITY) siftUp(heap, heap.length - 1, compare);
+      } else if (compare(entry, heap[0]) < 0) {
+        heap[0] = entry;
+        siftDown(heap, 0, compare);
+      }
+      return false;
+    },
+    finish() {
+      heap.sort(compare);
+      return heap.slice(skip).map((entry) => entry.item);
+    }
+  };
+}
+function keyOf(item, key) {
+  const values = [];
+  key.reach(item, (value) => {
+    values.push(value);
+    return false;
+  });
+  return sortValue(values, key.descending);
+}
+function siftUp(heap, at, compare) {
+  let child = at;
+  while (child > 0) {
+    const parent = child - 1 >> 1;
+    if (compare(heap[child], heap[parent]) <= 0) return;
+    [heap[child], heap[parent]] = [heap[parent], heap[child]];
+    child = parent;
+  }
+}
+function siftDown(heap, at, compare) {
+  let parent = at;
+  for (; ; ) {
+    const left = parent * 2 + 1;
+    const right = left + 1;
+    let largest = parent;
+    if (left < heap.length && compare(heap[left], heap[largest]) > 0) largest = left;
+    if (right < heap.length && compare(heap[right], heap[largest]) > 0) largest = right;
+    if (largest === parent) return;
+    [heap[parent], heap[largest]] = [heap[largest], heap[parent]];
+    parent = largest;
+  }
+}
+function projector(fields, vocabulary) {
+  if (!Array.isArray(fields)) throw new chunk74QKHM6Y_cjs.JqlError(`is a list of field names, not ${chunk74QKHM6Y_cjs.describe(fields)}`, "fields");
+  const tree = /* @__PURE__ */ new Map();
+  const computed = [];
+  fields.forEach((name, index) => {
+    const at = `fields[${index}]`;
+    if (typeof name !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a field name is a string, not ${chunk74QKHM6Y_cjs.describe(name)}`, at);
+    const field = vocabulary?.lookup.get(name.toLowerCase());
+    if (field?.get !== void 0) {
+      computed.push([field.name, field.get]);
+      return;
+    }
+    const keys = splitPath(field?.path ?? name);
+    if (typeof keys === "string") throw new chunk74QKHM6Y_cjs.JqlError(keys, at);
+    let node = tree;
+    for (let position = 0; position < keys.length; position++) {
+      const key = keys[position];
+      const existing = node.get(key);
+      if (existing === true) break;
+      if (position === keys.length - 1) {
+        node.set(key, true);
+        break;
+      }
+      if (existing === void 0) {
+        const child = /* @__PURE__ */ new Map();
+        node.set(key, child);
+        node = child;
+      } else node = existing;
+    }
+  });
+  return (item) => {
+    const out = pick(item, tree, 0) ?? {};
+    for (const [name, get] of computed) setField(out, name, get(item));
+    return out;
+  };
+}
+function redactor(omit, vocabulary) {
+  if (!Array.isArray(omit)) throw new chunk74QKHM6Y_cjs.JqlError(`is a list of field names, not ${chunk74QKHM6Y_cjs.describe(omit)}`, "omit");
+  const tree = /* @__PURE__ */ new Map();
+  omit.forEach((name, index) => {
+    const at = `omit[${index}]`;
+    if (typeof name !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a field name is a string, not ${chunk74QKHM6Y_cjs.describe(name)}`, at);
+    const field = vocabulary?.lookup.get(name.toLowerCase());
+    const keys = field?.get !== void 0 ? [field.name] : splitPath(field?.path ?? name);
+    if (typeof keys === "string") throw new chunk74QKHM6Y_cjs.JqlError(keys, at);
+    let node = tree;
+    for (let position = 0; position < keys.length; position++) {
+      const key = keys[position];
+      if (position === keys.length - 1) {
+        node.set(key, true);
+        break;
+      }
+      const existing = node.get(key);
+      if (existing === true) break;
+      if (existing === void 0) {
+        const child = /* @__PURE__ */ new Map();
+        node.set(key, child);
+        node = child;
+      } else node = existing;
+    }
+  });
+  return (item) => without(item, tree, 0);
+}
+var MAX_REDACT_DEPTH = 512;
+function without(value, tree, depth) {
+  if (depth > MAX_REDACT_DEPTH) {
+    throw new chunk74QKHM6Y_cjs.JqlError(`an item nests deeper than ${MAX_REDACT_DEPTH} levels, so it cannot be redacted; nothing was dropped from it`, "omit");
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const copy = value.map((element) => {
+      const kept = without(element, tree, depth + 1);
+      if (kept !== element) changed2 = true;
+      return kept;
+    });
+    return changed2 ? copy : value;
+  }
+  if (value instanceof Map) {
+    let changed2 = false;
+    const copy = /* @__PURE__ */ new Map();
+    for (const [key, held] of value) {
+      const sub = typeof key === "string" ? tree.get(key) : void 0;
+      if (sub === true) {
+        changed2 = true;
+        continue;
+      }
+      const kept = sub === void 0 ? held : without(held, sub, depth + 1);
+      if (kept !== held) changed2 = true;
+      copy.set(key, kept);
+    }
+    return changed2 ? copy : value;
+  }
+  const record = value;
+  const keys = Object.keys(record);
+  if (!keys.some((key) => tree.has(key))) return value;
+  const out = {};
+  let changed = false;
+  for (const key of keys) {
+    const sub = tree.get(key);
+    if (sub === true) {
+      changed = true;
+      continue;
+    }
+    const held = record[key];
+    const kept = sub === void 0 ? held : without(held, sub, depth + 1);
+    if (kept !== held) changed = true;
+    setField(out, key, kept);
+  }
+  return changed ? out : value;
+}
+function pick(value, tree, depth) {
+  if (value === null || typeof value !== "object" || depth > MAX_PATH_SEGMENTS) return void 0;
+  const out = {};
+  for (const [key, sub] of tree) {
+    const found = readOwn(value, key);
+    if (found === void 0) continue;
+    if (sub === true) setField(out, key, found);
+    else if (Array.isArray(found)) setField(out, key, found.map((element) => pick(element, sub, depth + 1)).filter((element) => element !== void 0));
+    else {
+      const inner = pick(found, sub, depth + 1);
+      if (inner !== void 0) setField(out, key, inner);
+    }
+  }
+  return out;
+}
+
+exports.CASE_AWARE = CASE_AWARE;
+exports.DEFAULT_LIMITS = DEFAULT_LIMITS;
+exports.FIELD_OPERATORS = FIELD_OPERATORS;
+exports.QUERY_OPERATORS = QUERY_OPERATORS;
+exports.UNTRUSTED_LIMITS = UNTRUSTED_LIMITS;
+exports.compareValues = compareValues;
+exports.compile = compile;
+exports.count = count2;
+exports.every = every;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterRecord = filterRecord;
+exports.find = find;
+exports.findEntry = findEntry;
+exports.findIndex = findIndex;
+exports.matches = matches;
+exports.partition = partition;
+exports.planRequest = planRequest;
+exports.reachField = reachField;
+exports.search = search;
+exports.some = some;
+exports.untyped = untyped;
+exports.validate = validate;
+//# sourceMappingURL=chunk-2ZMIVDES.cjs.map
+//# sourceMappingURL=chunk-2ZMIVDES.cjs.map