@osqd/jql 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,1937 +1,21 @@
 'use strict';
 
-// src/errors.ts
-var JqlError = class extends Error {
-  /**
-   * Where in the query the problem is, written the way you would reach it in code:
-   * `$or[1].age.$gt`. Empty for the query as a whole.
-   */
-  at;
-  constructor(message, at = "") {
-    super(at === "" ? message : `at ${show(at)}: ${message}`);
-    this.name = "JqlError";
-    this.at = at;
-  }
-};
-function show(at) {
-  return at.length > 80 ? `${at.slice(0, 80)}\u2026` : at;
-}
-
-// 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/duration.ts
-var PART = /(\d+)(ms|s|m|h|d|w)/g;
-var SHAPE = /^(?:\d+(?:ms|s|m|h|d|w))+$/;
-var UNITS = {
-  ms: 1,
-  s: 1e3,
-  m: 6e4,
-  h: 36e5,
-  d: 864e5,
-  w: 6048e5
-};
-var DURATION_UNITS = Object.keys(UNITS);
-function parseDuration(text2) {
-  if (!SHAPE.test(text2)) return void 0;
-  let total = 0;
-  PART.lastIndex = 0;
-  for (; ; ) {
-    const part = PART.exec(text2);
-    if (part === null) break;
-    const count4 = Number(part[1]);
-    if (!Number.isSafeInteger(count4)) return void 0;
-    total += count4 * UNITS[part[2]];
-  }
-  return Number.isSafeInteger(total) ? total : void 0;
-}
-
-// src/internal/values.ts
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isDateLiteral(value) {
-  if (!isPlainObject(value) || !("$date" in value)) return false;
-  for (const key in value) if (key !== "$date") return false;
-  return true;
-}
-function isFieldReference(value) {
-  if (!isPlainObject(value) || typeof value.$field !== "string") return false;
-  for (const key in value) if (key !== "$field") return false;
-  return true;
-}
-function resolveDate(value, now) {
-  if (typeof value === "number") return value;
-  if (typeof value === "string") return value === "now" ? now : instant(value);
-  if (isPlainObject(value)) {
-    const keys = Object.keys(value);
-    if (keys.length !== 1) return Number.NaN;
-    const amount = keys[0] === "$ago" || keys[0] === "$ahead" ? value[keys[0]] : void 0;
-    if (typeof amount !== "string") return Number.NaN;
-    const span = parseDuration(amount);
-    if (span === void 0) return Number.NaN;
-    return keys[0] === "$ago" ? now - span : now + span;
-  }
-  return Number.NaN;
-}
-var ISO_8601 = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
-var NO_OFFSET = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?)$/;
-function instant(text2) {
-  const bare = NO_OFFSET.exec(text2);
-  return bare === null ? Date.parse(text2) : Date.parse(`${bare[1]}T${bare[2]}Z`);
-}
-function toTime(value) {
-  if (typeof value === "number") return value;
-  if (value instanceof Date) return value.getTime();
-  if (typeof value === "string") return ISO_8601.test(value) ? instant(value) : Number.NaN;
-  return Number.NaN;
-}
-var TYPE_NAMES = ["string", "number", "integer", "bigint", "boolean", "null", "array", "object", "date"];
-function isOfType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" || typeof value === "bigint";
-    case "integer":
-      return Number.isInteger(value) || typeof value === "bigint";
-    case "bigint":
-      return typeof value === "bigint";
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    case "array":
-      return Array.isArray(value);
-    case "date":
-      return value instanceof Date;
-    case "object":
-      return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
-  }
-}
-function describe(value) {
-  if (value === null) return "null";
-  if (typeof value === "function") return "a function";
-  if (Array.isArray(value)) return "an array";
-  if (value instanceof RegExp) return "a RegExp object";
-  if (value instanceof Date) return "a Date object";
-  if (value instanceof Map) return "a Map";
-  if (value instanceof Set) return "a Set";
-  if (typeof value === "object") {
-    if (isPlainObject(value)) return "an object";
-    const name = nameOf(value);
-    return name === void 0 ? "an object" : `an instance of ${name}`;
-  }
-  if (typeof value === "string") return `the string ${JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}\u2026` : value)}`;
-  return `${typeof value} ${String(value)}`;
-}
-function nameOf(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const name = prototype?.constructor?.name;
-  return typeof name === "string" && name !== "" && name !== "Object" ? name : void 0;
-}
-
-// 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/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(literal2) {
-  return typeof literal2 === "number" && Number.isInteger(literal2) ? BigInt(literal2) : void 0;
-}
-function equalsLiteral(literal2, now, ignoreCase = false) {
-  if (literal2 === null) return (value) => value === null;
-  if (typeof literal2 !== "object") {
-    if (ignoreCase && typeof literal2 === "string") {
-      const wanted = literal2.toLowerCase();
-      return (value) => typeof value === "string" && value.toLowerCase() === wanted;
-    }
-    const big = alsoBig(literal2);
-    if (big !== void 0) return (value) => value === literal2 || value === big;
-    return (value) => value === literal2;
-  }
-  if (isDateLiteral(literal2)) {
-    const time = resolveDate(literal2.$date, now);
-    return (value) => toTime(value) === time;
-  }
-  return (value) => deepEqual(value, literal2, 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 = toTime(a);
-    const right = 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 (isDateLiteral(wanted)) return toTime(actual) === 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) || !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/internal/glob.ts
-var ANY = { any: true };
-var ONE = { one: true };
-function compileGlob(pattern) {
-  const tokens = tokenize(pattern);
-  const stars = tokens.includes(ANY);
-  const questions = tokens.includes(ONE);
-  if (!stars && !questions) {
-    const literal2 = tokens.join("");
-    return (text2) => text2 === literal2;
-  }
-  if (!questions) {
-    const segments = [""];
-    for (const token of tokens) {
-      if (token === ANY) segments.push("");
-      else segments[segments.length - 1] += token;
-    }
-    const open = segments[0] === "";
-    const close = segments[segments.length - 1] === "";
-    const parts = segments.filter((segment2) => segment2 !== "");
-    if (parts.length === 0) return () => true;
-    if (open && close && parts.length === 1) {
-      const inside = parts[0];
-      return (text2) => text2.includes(inside);
-    }
-    if (!open && close && parts.length === 1) {
-      const prefix = parts[0];
-      return (text2) => text2.startsWith(prefix);
-    }
-    if (open && !close && parts.length === 1) {
-      const suffix = parts[0];
-      return (text2) => text2.endsWith(suffix);
-    }
-    return (text2) => scan(text2, parts, open, close);
-  }
-  return (text2) => walk2([...text2], tokens);
-}
-function tokenize(pattern) {
-  const tokens = [];
-  let escaped = false;
-  for (const character of pattern) {
-    if (escaped) {
-      tokens.push(character);
-      escaped = false;
-      continue;
-    }
-    if (character === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (character === "*") {
-      if (tokens[tokens.length - 1] !== ANY) tokens.push(ANY);
-      continue;
-    }
-    tokens.push(character === "?" ? ONE : character);
-  }
-  if (escaped) tokens.push("\\");
-  return tokens;
-}
-function scan(text2, parts, open, close) {
-  let at = 0;
-  const last = parts.length - 1;
-  for (let i = 0; i <= last; i++) {
-    const part = parts[i];
-    if (i === 0 && !open) {
-      if (!text2.startsWith(part)) return false;
-      at = part.length;
-      continue;
-    }
-    if (i === last && !close) {
-      return text2.length - part.length >= at && text2.endsWith(part);
-    }
-    const found = text2.indexOf(part, at);
-    if (found === -1) return false;
-    at = found + part.length;
-  }
-  return true;
-}
-function walk2(characters, tokens) {
-  let at = 0;
-  let token = 0;
-  let star = -1;
-  let mark = 0;
-  while (at < characters.length) {
-    const current = tokens[token];
-    if (current !== void 0 && (current === ONE || current === characters[at])) {
-      at++;
-      token++;
-      continue;
-    }
-    if (current === ANY) {
-      star = token++;
-      mark = at;
-      continue;
-    }
-    if (star !== -1) {
-      token = star + 1;
-      at = ++mark;
-      continue;
-    }
-    return false;
-  }
-  while (tokens[token] === ANY) token++;
-  return token === tokens.length;
-}
-
-// src/operators.ts
-var NEVER = () => false;
-function lower(value) {
-  return value.toLowerCase();
-}
-function equalsTest(literal2, ignoreCase, at, now) {
-  checkLiteral(literal2, at);
-  if (literal2 === null) return (value) => value === null || value === void 0;
-  return equalsLiteral(literal2, now, ignoreCase);
-}
-function inTest(list, ignoreCase, at, now) {
-  if (!Array.isArray(list)) throw new JqlError(`takes a list of values, not ${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 fold2 = ignoreCase;
-  const whole = bigints;
-  return (value) => {
-    if (value === void 0 || value === null) return matchesMissing;
-    if (primitives.has(fold2 && 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 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 (isDateLiteral(bound)) {
-    const time = resolveDate(bound.$date, now);
-    if (Number.isNaN(time)) throw new 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 && toTime(value) > time;
-      case "$gte":
-        return (value) => value !== null && value !== void 0 && toTime(value) >= time;
-      case "$lt":
-        return (value) => value !== null && value !== void 0 && toTime(value) < time;
-      case "$lte":
-        return (value) => value !== null && value !== void 0 && toTime(value) <= time;
-    }
-  }
-  throw new JqlError(`compares with a number, a string, a {"$date": \u2026} or a {"$field": \u2026}, not ${describe(bound)}`, at);
-}
-function stringTest(operator, operand2, ignoreCase, at, maxGlobLength = Number.POSITIVE_INFINITY) {
-  const list = typeof operand2 === "string" ? [operand2] : operand2;
-  if (!Array.isArray(list)) throw new JqlError(`takes a string or a list of strings, not ${describe(operand2)}`, at);
-  if (list.length === 0) return NEVER;
-  const wanted = list.map((item, index) => {
-    if (typeof item !== "string") throw new JqlError(`takes strings, not ${describe(item)}`, `${at}[${index}]`);
-    return ignoreCase ? lower(item) : item;
-  });
-  if (operator === "$glob") {
-    for (const pattern of wanted) {
-      if (pattern.length > maxGlobLength) throw new JqlError(`the glob is ${pattern.length} characters, past the limit of ${maxGlobLength}`, at);
-    }
-    const globs = wanted.map(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(text2, at) {
-  const code = text2.charCodeAt(at - 1);
-  return code >= 56320 && code <= 57343 && at >= 2 ? text2.slice(at - 2, at) : text2[at - 1];
-}
-function after(text2, end) {
-  const code = text2.charCodeAt(end);
-  return code >= 55296 && code <= 56319 ? text2.slice(end, end + 2) : text2[end];
-}
-var OPTION_FLAGS = /* @__PURE__ */ new Set(["i", "m", "s", "u"]);
-function parseOptions(options, at) {
-  if (typeof options !== "string") throw new JqlError(`takes a string of flags such as "i", not ${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 JqlError(`"${flag}" is not a flag this language takes (i, m, s, u)${why}`, at);
-    }
-  }
-  if (new Set(options).size !== options.length) throw new JqlError(`"${options}" repeats a flag`, at);
-  return options;
-}
-function regexTest(pattern, flags, limits, at) {
-  if (!limits.allowRegex) throw new 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 JqlError(`takes the pattern as a string, not ${describe(pattern)}`, at);
-  if (pattern.length > limits.maxPatternLength) throw new 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 JqlError(`the pattern does not compile: ${error instanceof Error ? error.message : String(error)}`, at);
-  }
-  return (value) => typeof value === "string" && expression.test(value);
-}
-function typeTest(operand2, at) {
-  const list = typeof operand2 === "string" ? [operand2] : operand2;
-  if (!Array.isArray(list) || list.length === 0) throw new JqlError(`takes a type name or a non-empty list of them, not ${describe(operand2)}`, at);
-  const types = list.map((name, index) => {
-    if (typeof name !== "string" || !TYPE_NAMES.includes(name)) {
-      throw new JqlError(`${describe(name)} is not a type name (${TYPE_NAMES.join(", ")})${typeof name === "string" ? didYouMean(name, TYPE_NAMES) : ""}`, `${at}[${index}]`);
-    }
-    return name;
-  });
-  if (types.length === 1) {
-    const only = types[0];
-    return (value) => isOfType(value, only);
-  }
-  return (value) => types.some((type) => isOfType(value, type));
-}
-function modTest(operand2, at) {
-  if (!Array.isArray(operand2) || operand2.length !== 2 || typeof operand2[0] !== "number" || typeof operand2[1] !== "number") {
-    throw new JqlError(`takes [divisor, remainder], not ${describe(operand2)}`, at);
-  }
-  const [divisor, remainder] = operand2;
-  if (divisor === 0 || !Number.isFinite(divisor)) throw new 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 JqlError(`takes a list of values, not ${describe(list)}`, at);
-  if (list.length === 0) return NEVER;
-  const tests = list.map((item, index) => {
-    if (isPlainObject(item) && Object.keys(item).some((key) => key.startsWith("$")) && !isDateLiteral(item)) {
-      throw new 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 JqlError(`${String(value)} is not a JSON number`, at);
-    return;
-  }
-  if (depth > 64) throw new 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 (isPlainObject(value)) {
-    if (isFieldReference(value)) {
-      throw new 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 (isDateLiteral(value)) {
-      const date = value.$date;
-      if (Number.isNaN(resolveDate(date, 0))) {
-        const relative = isPlainObject(date) ? `; a relative date is {"$ago": "1h"} or {"$ahead": "1h"}, with a count and one of ${DURATION_UNITS.join(", ")}` : "";
-        throw new 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 JqlError(`${describe(value)} is not JSON, so a query holding it could not be stored or sent${hint}`, at);
-}
-
-// src/vocabulary.ts
-var BAD_NAME = /^\$|\./;
-function defineVocabulary() {
-  return (definition) => build(definition);
-}
-function checkVocabulary(value, at = "vocabulary") {
-  if (value === void 0 || value !== null && typeof value === "object" && value.lookup instanceof Map) return value;
-  throw new JqlError(
-    `is not a vocabulary, but ${describe(value)}: build one with defineVocabulary()({ fields: \u2026 }) \u2014 the empty parentheses first \u2014 and pass what that returns`,
-    at
-  );
-}
-function build(definition) {
-  const lookup = /* @__PURE__ */ new Map();
-  const fields = [];
-  const claim = (name, field) => {
-    const key = name.toLowerCase();
-    if (name === "" || BAD_NAME.test(name)) throw new JqlError(`"${name}" cannot name a field: a field name is not empty, does not start with "$" and has no "."`, "vocabulary");
-    const holder = lookup.get(key);
-    if (holder !== void 0) {
-      throw new JqlError(`"${name}" names both "${holder.name}" and "${field.name}", so a query using it could mean either`, "vocabulary");
-    }
-    lookup.set(key, field);
-  };
-  for (const [name, spec] of Object.entries(definition.fields)) {
-    if (spec.path !== void 0 && spec.get !== void 0) {
-      throw new JqlError(`"${name}" has both a path and a getter; one of them would be ignored, so say which`, `vocabulary.${name}`);
-    }
-    if (spec.path === "") throw new JqlError(`"${name}" has an empty path, which reaches nothing`, `vocabulary.${name}`);
-    const field = {
-      name,
-      kind: spec.kind ?? "text",
-      path: spec.path ?? name,
-      get: spec.get,
-      aliases: spec.aliases ?? [],
-      values: spec.values
-    };
-    fields.push(field);
-    claim(name, field);
-    for (const alias of field.aliases) claim(alias, field);
-  }
-  if (definition.text !== void 0) {
-    for (const name of definition.text) {
-      if (!lookup.has(name.toLowerCase())) throw new JqlError(`the text field "${name}" is not a field of this vocabulary, so a bare word would never search it`, "vocabulary.text");
-    }
-  }
-  return {
-    lookup,
-    fields,
-    names: [...lookup.keys()].sort(),
-    text: definition.text,
-    strict: definition.strict ?? false
-  };
-}
-
-// 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: 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 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 JqlError(`is a list of operator names or "all", not ${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 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 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 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 JqlError(`"${definition.name}" is given twice, and the two could not both be it`, "operators");
-    if (typeof definition.compile !== "function") throw new 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 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 JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);
-  if (!isPlainObject(query)) throw new JqlError(`a query is an object, not ${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 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 JqlError(`a comment is a string, not ${describe(value)}`, here);
-        break;
-      default:
-        if (!FIELD_OPERATOR_SET.has(key)) throw new 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 JqlError(`takes a list of queries, not ${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 JqlError(rest, at);
-        return fieldOf(head, rest, at);
-      }
-    }
-    if (vocabulary.strict) throw new JqlError(`"${name}" is not a field here${didYouMean(name, vocabulary.names)}`, at);
-  }
-  const keys = splitPath(name);
-  if (typeof keys === "string") throw new 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 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 (isFieldReference(value)) {
-    permit("$field", context, at);
-    permit("$eq", context, at);
-    return compareFields(field, "$eq", value.$field, false, context, at);
-  }
-  if (isPlainObject(value) && !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 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, condition2, context, at, depth) {
-  const { values: values2, whole } = conditionParts(field, condition2, context, at, depth);
-  return combine(field, values2, whole);
-}
-function combine(field, values2, whole) {
-  const parts = [...whole];
-  if (values2.length > 0) {
-    const cost = values2.reduce((sum, value) => sum + value.cost, 0);
-    if (field.read !== void 0) {
-      const only = values2.length === 1 ? values2[0] : void 0;
-      parts.push(only !== void 0 && only.any !== void 0 ? holdsAny(field, only.any, only.negated, cost) : holds(field, allOfValues(values2), cost));
-    } else {
-      const separate = allOf(values2.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(values2);
-        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, condition2, context, at, depth) {
-  if (depth > context.limits.maxDepth) throw new JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);
-  let flags = "";
-  if (condition2.$options !== void 0) {
-    flags = parseOptions(condition2.$options, join(at, "$options"));
-    const usesCase = Object.keys(condition2).some((key) => CASE_AWARE.has(key));
-    if (!usesCase) throw new 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) && condition2.$regex === void 0) throw new 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 values2 = [];
-  const whole = [];
-  const add = (test, cost, negated = false) => {
-    values2.push({ test, cost, negated, any: void 0 });
-  };
-  const addAny = (test, cost, negated = false) => {
-    values2.push({ test: elementwise(test), cost, negated, any: test });
-  };
-  for (const key in condition2) {
-    const operand2 = condition2[key];
-    const here = join(at, key);
-    if (operand2 === void 0) throw new 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(operand2, here);
-        if (reference !== void 0) {
-          permit("$field", context, here);
-          whole.push(compareFields(field, "$eq", reference, negated, context, here));
-          break;
-        }
-        add(equalsValue(operand2, ignoreCase, here, context.now), operand2 !== null && typeof operand2 === "object" ? 3 : 0, negated);
-        break;
-      }
-      case "$gt":
-      case "$gte":
-      case "$lt":
-      case "$lte":
-        {
-          const reference = referencePath(operand2, here);
-          if (reference !== void 0) {
-            permit("$field", context, here);
-            whole.push(compareFields(field, key, reference, false, context, here));
-            break;
-          }
-          addAny(orderTest(key, operand2, here, context.now), 1);
-        }
-        break;
-      case "$in":
-        addAny(inTest(operand2, ignoreCase, here, context.now), 1);
-        break;
-      case "$nin":
-        addAny(inTest(operand2, ignoreCase, here, context.now), 1, true);
-        break;
-      case "$exists":
-        if (typeof operand2 !== "boolean") throw new JqlError(`takes true or false, not ${describe(operand2)}`, here);
-        add(isPresent, 0, !operand2);
-        break;
-      case "$type":
-        addAny(typeTest(operand2, here), 1);
-        break;
-      case "$contains":
-      case "$startsWith":
-      case "$endsWith":
-      case "$word":
-      case "$glob":
-        addAny(stringTest(key, operand2, ignoreCase, here, context.limits.maxGlobLength), key === "$word" || key === "$glob" ? 4 : 2);
-        break;
-      case "$regex":
-        addAny(regexTest(operand2, flags, context.limits, here), 5);
-        break;
-      case "$mod":
-        addAny(modTest(operand2, here), 1);
-        break;
-      case "$size":
-        add(sizeTest(operand2, context, here, depth, "array"), 1);
-        break;
-      case "$length":
-        add(sizeTest(operand2, context, here, depth, "anything with a length"), 1);
-        break;
-      case "$all":
-        add(allTest(operand2, ignoreCase, here, context.now), 4);
-        break;
-      case "$elemMatch": {
-        if (!isPlainObject(operand2)) throw new JqlError(`takes a query for one element, not ${describe(operand2)}`, here);
-        const element = compileQuery(operand2, 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 (!isPlainObject(operand2) || isDateLiteral(operand2) || !Object.keys(operand2).every((name) => name.startsWith("$"))) {
-          throw new JqlError(`takes a condition such as { "$gt": 5 }, not ${describe(operand2)}; to negate a value, use $ne`, here);
-        }
-        const inner = conditionParts(field, operand2, 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(operand2, here);
-          if (typeof test !== "function") throw new 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 reason2 = 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 JqlError(reason2, here);
-      }
-    }
-  }
-  return { values: values2, whole };
-}
-function allOfValues(values2) {
-  const tests = [...values2].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(literal2, ignoreCase, at, now) {
-  if (!ignoreCase && (typeof literal2 === "string" || typeof literal2 === "number" || typeof literal2 === "boolean")) {
-    checkLiteral(literal2, at);
-    const wanted = literal2;
-    const big = alsoBig(literal2);
-    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(literal2, ignoreCase, at, now));
-}
-function equality(field, literal2, ignoreCase, at, now) {
-  const key = field.key;
-  if (key !== void 0 && !ignoreCase && (typeof literal2 === "string" || typeof literal2 === "number" || typeof literal2 === "boolean")) {
-    checkLiteral(literal2, at);
-    const wanted = literal2;
-    const reach = field.reach;
-    const plain = !needsGuard(key);
-    const test = equalsValue(literal2, false, at, now);
-    const big = alsoBig(literal2);
-    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 literal2 === "string" || typeof literal2 === "number" || typeof literal2 === "boolean")) {
-    checkLiteral(literal2, at);
-    const wanted = literal2;
-    const test = equalsValue(literal2, false, at, now);
-    const reach = field.reach;
-    const big = alsoBig(literal2);
-    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(literal2, ignoreCase, at, now), literal2 !== null && typeof literal2 === "object" ? 3 : 0);
-}
-function sizeTest(operand2, context, at, depth, measures) {
-  const strings = measures !== "array";
-  let length;
-  if (typeof operand2 === "number") {
-    if (!Number.isInteger(operand2) || operand2 < 0) throw new JqlError(`a length is a whole number, not ${operand2}`, at);
-    length = (size) => size === operand2;
-  } else if (isPlainObject(operand2)) {
-    length = compileCondition(SELF, operand2, context, at, depth + 1).test;
-  } else throw new JqlError(`takes a number or a condition on one, not ${describe(operand2)}`, 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(operand2, at) {
-  if (!isPlainObject(operand2) || !("$field" in operand2)) return void 0;
-  if (typeof operand2.$field !== "string") throw new JqlError(`a {"$field": \u2026} reference takes the path as a string, not ${describe(operand2.$field)}`, at);
-  const beside = Object.keys(operand2).filter((key) => key !== "$field");
-  if (beside.length > 0) throw new JqlError(`a {"$field": \u2026} reference holds nothing but the path, and "${beside[0]}" is beside it`, at);
-  return operand2.$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 (isPlainObject(value)) {
-    for (const key in value) {
-      if (key !== "$search" && key !== "$fields" && key !== "$caseSensitive") {
-        throw new 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 JqlError(`takes a phrase or { "$search": \u2026 }, not ${describe(value)}`, at);
-  if (typeof search2 !== "string") throw new JqlError(`the phrase is a string, not ${describe(search2)}`, join(at, "$search"));
-  if (typeof caseSensitive !== "boolean") throw new JqlError(`takes true or false, not ${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 ? (text2) => text2.includes(needle) : (text2) => text2.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 JqlError(`takes a non-empty list of field names, not ${describe(names)}`, join(at, "$fields"));
-  return names.map((name, index) => {
-    if (typeof name !== "string") throw new JqlError(`a field name is a string, not ${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 walk3(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;
-  walk3(source, (item) => {
-    if (!test(item)) return false;
-    found = item;
-    return true;
-  });
-  return found;
-}
-function findIndex(source, query, options) {
-  return walk3(source, compile(query, options));
-}
-function filter(source, query, options) {
-  const test = compile(query, options);
-  const out = [];
-  walk3(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;
-  walk3(source, (item) => {
-    if (test(item)) total++;
-    return false;
-  });
-  return total;
-}
-function some(source, query, options) {
-  return walk3(source, compile(query, options)) !== -1;
-}
-function every(source, query, options) {
-  const test = compile(query, options);
-  return walk3(source, (item) => !test(item)) === -1;
-}
-function partition(source, query, options) {
-  const test = compile(query, options);
-  const yes = [];
-  const no = [];
-  walk3(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(values2, descending, depth = 0) {
-  let best;
-  let first = true;
-  for (const value of values2) {
-    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 plan2 = planRequest(request, options);
-  const collect2 = plan2.collect();
-  const test = plan2.test;
-  each(source, (item, index) => {
-    if (test !== void 0 && !test(item)) return false;
-    return collect2.offer(item, index);
-  });
-  return plan2.shape(collect2.finish());
-}
-function planRequest(request, options) {
-  if (!isPlainObject(request)) throw new JqlError(`a request is an object, not ${describe(request)}`);
-  for (const key of Object.keys(request)) {
-    if (!REQUEST_KEYS.includes(key)) throw new JqlError(`"${key}" is not part of a request (${REQUEST_KEYS.join(", ")})${didYouMean(key, REQUEST_KEYS)}`, key);
-  }
-  const vocabulary = 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 JqlError(`is a whole number of items, zero or more, not ${describe(value)}`, name);
-  }
-  return value;
-}
-function sortKeys(sort, vocabulary) {
-  if (sort === void 0) return [];
-  if (!isPlainObject(sort)) throw new JqlError(`is an object of field names to directions, not ${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 JqlError(`a direction is 1, -1, "asc" or "desc", not ${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 values2 = [];
-  key.reach(item, (value) => {
-    values2.push(value);
-    return false;
-  });
-  return sortValue(values2, 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 JqlError(`is a list of field names, not ${describe(fields)}`, "fields");
-  const tree = /* @__PURE__ */ new Map();
-  const computed = [];
-  fields.forEach((name, index) => {
-    const at = `fields[${index}]`;
-    if (typeof name !== "string") throw new JqlError(`a field name is a string, not ${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 JqlError(keys, at);
-    let node2 = tree;
-    for (let position = 0; position < keys.length; position++) {
-      const key = keys[position];
-      const existing = node2.get(key);
-      if (existing === true) break;
-      if (position === keys.length - 1) {
-        node2.set(key, true);
-        break;
-      }
-      if (existing === void 0) {
-        const child = /* @__PURE__ */ new Map();
-        node2.set(key, child);
-        node2 = child;
-      } else node2 = 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 JqlError(`is a list of field names, not ${describe(omit)}`, "omit");
-  const tree = /* @__PURE__ */ new Map();
-  omit.forEach((name, index) => {
-    const at = `omit[${index}]`;
-    if (typeof name !== "string") throw new JqlError(`a field name is a string, not ${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 JqlError(keys, at);
-    let node2 = tree;
-    for (let position = 0; position < keys.length; position++) {
-      const key = keys[position];
-      if (position === keys.length - 1) {
-        node2.set(key, true);
-        break;
-      }
-      const existing = node2.get(key);
-      if (existing === true) break;
-      if (existing === void 0) {
-        const child = /* @__PURE__ */ new Map();
-        node2.set(key, child);
-        node2 = child;
-      } else node2 = existing;
-    }
-  });
-  return (item) => without(item, tree, 0);
-}
-var MAX_REDACT_DEPTH = 512;
-function without(value, tree, depth) {
-  if (depth > MAX_REDACT_DEPTH) {
-    throw new 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;
-}
+var chunk2ZMIVDES_cjs = require('./chunk-2ZMIVDES.cjs');
+var chunkEJFHVGBC_cjs = require('./chunk-EJFHVGBC.cjs');
+require('./chunk-ITPY6VTV.cjs');
+var chunk74QKHM6Y_cjs = require('./chunk-74QKHM6Y.cjs');
 
 // src/group.ts
 function group(source, by, options = {}) {
-  if (typeof by !== "string") throw new JqlError(`a group is named by a field, not ${describe(by)}`, "by");
+  if (typeof by !== "string") throw new chunk74QKHM6Y_cjs.JqlError(`a group is named by a field, not ${chunk74QKHM6Y_cjs.describe(by)}`, "by");
   if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 0)) {
-    throw new JqlError(`is a whole number of groups, zero or more, not ${describe(options.limit)}`, "limit");
+    throw new chunk74QKHM6Y_cjs.JqlError(`is a whole number of groups, zero or more, not ${chunk74QKHM6Y_cjs.describe(options.limit)}`, "limit");
   }
   if (options.items !== void 0 && typeof options.items !== "boolean" && (!Number.isInteger(options.items) || options.items < 0)) {
-    throw new JqlError(`is true, false, or how many items to keep, not ${describe(options.items)}`, "items");
+    throw new chunk74QKHM6Y_cjs.JqlError(`is true, false, or how many items to keep, not ${chunk74QKHM6Y_cjs.describe(options.items)}`, "items");
   }
-  const reach = reachField(by, checkVocabulary(options.vocabulary), "by");
-  const test = options.where === void 0 ? void 0 : compile(options.where, options);
+  const reach = chunk2ZMIVDES_cjs.reachField(by, chunkEJFHVGBC_cjs.checkVocabulary(options.vocabulary), "by");
+  const test = options.where === void 0 ? void 0 : chunk2ZMIVDES_cjs.compile(options.where, options);
   const keep = options.items === true ? Number.POSITIVE_INFINITY : options.items === void 0 || options.items === false ? 0 : options.items;
   const groups = /* @__PURE__ */ new Map();
   const keys = [];
@@ -1960,7 +44,7 @@ function group(source, by, options = {}) {
     for (let i = 0; i < list.length; i++) visit(list[i]);
   }
   const byKey = options.sort === "key";
-  const found = [...groups.values()].sort((a, b) => byKey ? compareValues(a.key, b.key) : b.count - a.count || compareValues(a.key, b.key));
+  const found = [...groups.values()].sort((a, b) => byKey ? chunk2ZMIVDES_cjs.compareValues(a.key, b.key) : b.count - a.count || chunk2ZMIVDES_cjs.compareValues(a.key, b.key));
   const limited = options.limit === void 0 ? found : found.slice(0, options.limit);
   return limited.map((held) => keep > 0 ? { key: held.key, count: held.count, items: held.items } : { key: held.key, count: held.count });
 }
@@ -1978,21 +62,21 @@ function collect(value, into) {
 }
 
 // src/explain.ts
-var FIELD_OPERATOR_SET2 = new Set(FIELD_OPERATORS);
+var FIELD_OPERATOR_SET = new Set(chunk2ZMIVDES_cjs.FIELD_OPERATORS);
 function explain(query, item, options = {}) {
   return node(query, item, "", options);
 }
 function matchedBy(clause, item, options) {
-  return compile(clause, options)(item);
+  return chunk2ZMIVDES_cjs.compile(clause, options)(item);
 }
 function node(clause, item, at, options) {
-  if (typeof clause === "function" || !isPlainObject(clause)) {
+  if (typeof clause === "function" || !chunk74QKHM6Y_cjs.isPlainObject(clause)) {
     return leaf(clause, item, at, options, typeof clause === "function" ? "a predicate of your own" : "the whole query");
   }
   const keys = Object.keys(clause);
   if (keys.length === 0) return { matched: true, at, clause, because: "an empty query matches everything" };
   if (keys.length > 1) {
-    const self = keys.filter((key2) => key2 !== "$not" && FIELD_OPERATOR_SET2.has(key2));
+    const self = keys.filter((key2) => key2 !== "$not" && FIELD_OPERATOR_SET.has(key2));
     const rest = keys.filter((key2) => !self.includes(key2));
     const parts = rest.map((key2) => node({ [key2]: clause[key2] }, item, at, options));
     if (self.length > 0) {
@@ -2004,7 +88,7 @@ function node(clause, item, at, options) {
   }
   const key = keys[0];
   const value = clause[key];
-  const here = join2(at, key);
+  const here = join(at, key);
   switch (key) {
     case "$and":
     case "$or":
@@ -2024,10 +108,10 @@ function node(clause, item, at, options) {
       };
     }
   }
-  if (!key.startsWith("$") && isPlainObject(value) && !isFieldReference(value) && Object.keys(value).length > 1 && Object.keys(value).every((name) => name.startsWith("$"))) {
+  if (!key.startsWith("$") && chunk74QKHM6Y_cjs.isPlainObject(value) && !chunk74QKHM6Y_cjs.isFieldReference(value) && Object.keys(value).length > 1 && Object.keys(value).every((name) => name.startsWith("$"))) {
     const operators = Object.keys(value).filter((name) => name !== "$options");
     const flags = value.$options === void 0 ? {} : { $options: value.$options };
-    const parts = operators.map((name) => leaf({ [key]: { [name]: value[name], ...CASE_AWARE.has(name) ? flags : {} } }, item, join2(here, name), options, key));
+    const parts = operators.map((name) => leaf({ [key]: { [name]: value[name], ...chunk2ZMIVDES_cjs.CASE_AWARE.has(name) ? flags : {} } }, item, join(here, name), options, key));
     return branch(clause, here, parts, "and");
   }
   return leaf(clause, item, here, options, key);
@@ -2046,13 +130,13 @@ function leaf(clause, item, at, options, key) {
 function reason(clause, item, options, key) {
   if (key === "$text") return matchedBy(clause, item, options) ? "the item holds that text" : "no value of the item holds that text";
   if (key === "$comment") return "a comment decides nothing";
-  if (key.startsWith("$") && FIELD_OPERATOR_SET2.has(key)) return `the item itself is ${values(item === void 0 ? [] : [item])}`;
-  if (!isPlainObject(clause)) return "the clause was run as given";
+  if (key.startsWith("$") && FIELD_OPERATOR_SET.has(key)) return `the item itself is ${values(item === void 0 ? [] : [item])}`;
+  if (!chunk74QKHM6Y_cjs.isPlainObject(clause)) return "the clause was run as given";
   const path = Object.keys(clause)[0];
   if (path === void 0 || path.startsWith("$")) return "the clause was run as given";
   const found = [];
   try {
-    reachField(path, options.vocabulary, path)(item, (value) => {
+    chunk2ZMIVDES_cjs.reachField(path, options.vocabulary, path)(item, (value) => {
       if (found.length < 4) found.push(value);
       return false;
     });
@@ -2076,7 +160,7 @@ function shorten(value) {
   }
   return text2.length > 60 ? `${text2.slice(0, 60)}\u2026` : text2;
 }
-function join2(at, key) {
+function join(at, key) {
   return at === "" ? key : `${at}.${key}`;
 }
 
@@ -2086,15 +170,15 @@ var QUERIES = /* @__PURE__ */ new Set(["$elemMatch"]);
 var LOGIC = /* @__PURE__ */ new Set(["$and", "$or", "$nor"]);
 function canonical(query, options) {
   if (typeof query === "function") throw new TypeError("a compiled predicate has no canonical form: it is code, not a query");
-  compile(query, options);
+  chunk2ZMIVDES_cjs.compile(query, options);
   return rewrite(query);
 }
 function fingerprint(query, options) {
   return checksum(JSON.stringify(canonical(query, options)) ?? "");
 }
 function rewrite(value) {
-  if (!isPlainObject(value)) return value;
-  if (isDateLiteral(value) || isFieldReference(value)) return value;
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value)) return value;
+  if (chunk74QKHM6Y_cjs.isDateLiteral(value) || chunk74QKHM6Y_cjs.isFieldReference(value)) return value;
   const out = {};
   const keys = Object.keys(value).sort().filter((key) => key !== "$comment");
   const alone = keys.length === 1;
@@ -2129,7 +213,7 @@ function fold(out) {
   const lifted = {};
   const kept = [];
   for (const part of parts) {
-    const keys = isPlainObject(part) ? Object.keys(part) : void 0;
+    const keys = chunk74QKHM6Y_cjs.isPlainObject(part) ? Object.keys(part) : void 0;
     if (keys === void 0 || keys.length === 0 || keys.some((key) => taken.has(key))) {
       kept.push(part);
       continue;
@@ -2148,7 +232,7 @@ function fold(out) {
   return sorted;
 }
 function condition(value) {
-  if (isPlainObject(value) && !isDateLiteral(value) && !isFieldReference(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => key.startsWith("$"))) {
+  if (chunk74QKHM6Y_cjs.isPlainObject(value) && !chunk74QKHM6Y_cjs.isDateLiteral(value) && !chunk74QKHM6Y_cjs.isFieldReference(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => key.startsWith("$"))) {
     const out = {};
     for (const key of Object.keys(value).sort()) out[key] = key === "$not" ? condition(value[key]) : operand(key, value[key]);
     return out;
@@ -2163,18 +247,18 @@ function operand(key, value) {
     return types.length === 1 ? types[0] : types;
   }
   if (key === "$options" && typeof value === "string") return [...value].sort().join("");
-  if ((key === "$size" || key === "$length") && isPlainObject(value)) return condition(value);
+  if ((key === "$size" || key === "$length") && chunk74QKHM6Y_cjs.isPlainObject(value)) return condition(value);
   return literal(value);
 }
 function literal(value) {
   if (Array.isArray(value)) return value.map(literal);
-  if (!isPlainObject(value) || isDateLiteral(value) || isFieldReference(value)) return value;
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value) || chunk74QKHM6Y_cjs.isDateLiteral(value) || chunk74QKHM6Y_cjs.isFieldReference(value)) return value;
   const out = {};
   for (const key of Object.keys(value).sort()) out[key] = literal(value[key]);
   return out;
 }
 function text(value) {
-  const search2 = typeof value === "string" ? { $search: value } : isPlainObject(value) ? value : void 0;
+  const search2 = typeof value === "string" ? { $search: value } : chunk74QKHM6Y_cjs.isPlainObject(value) ? value : void 0;
   if (search2 === void 0) return value;
   const out = { $search: search2.$search };
   if (Array.isArray(search2.$fields)) out.$fields = unique(search2.$fields);
@@ -2185,7 +269,7 @@ function flatten(key, parts) {
   if (key === "$nor") return [...parts];
   const out = [];
   for (const part of parts) {
-    const inner = isPlainObject(part) && Object.keys(part).length === 1 ? part[key] : void 0;
+    const inner = chunk74QKHM6Y_cjs.isPlainObject(part) && Object.keys(part).length === 1 ? part[key] : void 0;
     if (Array.isArray(inner)) out.push(...flatten(key, inner));
     else out.push(part);
   }
@@ -2216,10 +300,10 @@ function checksum(text2) {
 }
 
 // src/plan.ts
-var KNOWN = /* @__PURE__ */ new Set([...FIELD_OPERATORS, ...QUERY_OPERATORS, "$field"]);
+var KNOWN = /* @__PURE__ */ new Set([...chunk2ZMIVDES_cjs.FIELD_OPERATORS, ...chunk2ZMIVDES_cjs.QUERY_OPERATORS, "$field"]);
 function plan(query, capabilities, options = {}) {
   if (typeof query === "function") throw new TypeError("a compiled predicate cannot be split: it is code, not a query");
-  const verdict = validate(query, options);
+  const verdict = chunk2ZMIVDES_cjs.validate(query, options);
   if (!verdict.valid) throw verdict.error;
   const now = options.now === void 0 ? Date.now() : options.now();
   const vocabulary = options.vocabulary;
@@ -2246,8 +330,8 @@ function plan(query, capabilities, options = {}) {
     }
   }
   return {
-    pushed: join3(pushed),
-    remaining: join3(stays),
+    pushed: join2(pushed),
+    remaining: join2(stays),
     complete: stays.length === 0,
     kept
   };
@@ -2259,7 +343,7 @@ function conjuncts(query, at) {
     if (key === "$comment") continue;
     if (key === "$and" && Array.isArray(value)) {
       value.forEach((part, index) => {
-        if (isPlainObject(part)) out.push(...conjuncts(part, `${here}[${index}]`));
+        if (chunk74QKHM6Y_cjs.isPlainObject(part)) out.push(...conjuncts(part, `${here}[${index}]`));
       });
       continue;
     }
@@ -2267,7 +351,7 @@ function conjuncts(query, at) {
   }
   return out;
 }
-function join3(parts) {
+function join2(parts) {
   if (parts.length === 0) return void 0;
   const query = parts.length === 1 ? parts[0] : { $and: parts };
   return query;
@@ -2289,7 +373,7 @@ function unpushableOperator(key, value, context, at) {
     case "$and":
       if (!Array.isArray(value)) return "the clause is malformed";
       for (const part of value) {
-        if (!isPlainObject(part)) return "the clause is malformed";
+        if (!chunk74QKHM6Y_cjs.isPlainObject(part)) return "the clause is malformed";
         const why = unpushable(part, context);
         if (why !== void 0) return why;
       }
@@ -2301,7 +385,7 @@ function unpushableOperator(key, value, context, at) {
       if (!context.or && key === "$nor") return "the store cannot answer an $or";
       if (!Array.isArray(value) || value.length === 0) return "the clause is malformed";
       for (const part of value) {
-        if (!isPlainObject(part)) return "the clause is malformed";
+        if (!chunk74QKHM6Y_cjs.isPlainObject(part)) return "the clause is malformed";
         const why = unpushable(part, context);
         if (why !== void 0) return why;
       }
@@ -2309,7 +393,7 @@ function unpushableOperator(key, value, context, at) {
     }
     case "$not": {
       if (!context.not) return "the store cannot answer a negation";
-      if (!isPlainObject(value)) return "the clause is malformed";
+      if (!chunk74QKHM6Y_cjs.isPlainObject(value)) return "the clause is malformed";
       return unpushable(value, context);
     }
     case "$text":
@@ -2323,8 +407,8 @@ function unpushableField(name, value, context, at) {
   if (field?.get !== void 0) return `"${name}" is computed here, so the store has no such field`;
   const stored = storedName(name, context);
   if (context.fields !== "all" && !context.fields.has(stored)) return `the store cannot filter on "${stored}"`;
-  if (isFieldReference(value)) return allows(context, "$field") ? void 0 : "the store cannot compare two fields";
-  if (!isPlainObject(value) || isDateLiteral(value)) {
+  if (chunk74QKHM6Y_cjs.isFieldReference(value)) return allows(context, "$field") ? void 0 : "the store cannot compare two fields";
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value) || chunk74QKHM6Y_cjs.isDateLiteral(value)) {
     if (!allows(context, "$eq")) return 'the store cannot answer "$eq"';
     return accepted(context, stored, { $eq: value });
   }
@@ -2341,14 +425,14 @@ function unpushableField(name, value, context, at) {
       return "the store cannot answer a negation";
     }
     const operand2 = value[key];
-    if (isFieldReference(operand2) && !allows(context, "$field")) return "the store cannot compare two fields";
+    if (chunk74QKHM6Y_cjs.isFieldReference(operand2) && !allows(context, "$field")) return "the store cannot compare two fields";
     if (key === "$elemMatch") {
-      if (!isPlainObject(operand2)) return "the clause is malformed";
+      if (!chunk74QKHM6Y_cjs.isPlainObject(operand2)) return "the clause is malformed";
       const why = unpushable(operand2, context);
       if (why !== void 0) return why;
     }
     if (key === "$not") {
-      if (!isPlainObject(operand2)) return "the clause is malformed";
+      if (!chunk74QKHM6Y_cjs.isPlainObject(operand2)) return "the clause is malformed";
       const why = unpushableField(name, operand2, context);
       if (why !== void 0) return why;
     }
@@ -2363,7 +447,7 @@ function allows(context, operator) {
   return context.operators === "all" || context.operators.has(operator);
 }
 function resolve(value, context) {
-  if (!isPlainObject(value)) return value;
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value)) return value;
   const out = {};
   for (const [key, held] of Object.entries(value)) {
     switch (key) {
@@ -2387,8 +471,8 @@ function resolve(value, context) {
   return out;
 }
 function resolveCondition(value, context) {
-  if (!isPlainObject(value)) return resolveLiteral(value, context);
-  if (isDateLiteral(value) || isFieldReference(value)) return resolveOperand("$eq", value, context);
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value)) return resolveLiteral(value, context);
+  if (chunk74QKHM6Y_cjs.isDateLiteral(value) || chunk74QKHM6Y_cjs.isFieldReference(value)) return resolveOperand("$eq", value, context);
   const keys = Object.keys(value);
   if (keys.length === 0 || !keys.every((key) => key.startsWith("$"))) return resolveLiteral(value, context);
   const out = {};
@@ -2398,20 +482,20 @@ function resolveCondition(value, context) {
 function resolveOperand(key, operand2, context) {
   if (key === "$elemMatch") return resolve(operand2, context);
   if (key === "$not") return resolveCondition(operand2, context);
-  if (isFieldReference(operand2)) return { $field: storedName(operand2.$field, context) };
-  if (Array.isArray(operand2)) return operand2.map((item) => isFieldReference(item) ? { $field: storedName(item.$field, context) } : resolveLiteral(item, context));
+  if (chunk74QKHM6Y_cjs.isFieldReference(operand2)) return { $field: storedName(operand2.$field, context) };
+  if (Array.isArray(operand2)) return operand2.map((item) => chunk74QKHM6Y_cjs.isFieldReference(item) ? { $field: storedName(item.$field, context) } : resolveLiteral(item, context));
   return resolveLiteral(operand2, context);
 }
 function resolveText(value, context) {
-  if (!isPlainObject(value) || !Array.isArray(value.$fields)) return value;
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value) || !Array.isArray(value.$fields)) return value;
   return { ...value, $fields: value.$fields.map((name) => typeof name === "string" ? storedName(name, context) : name) };
 }
 function resolveLiteral(value, context) {
   if (Array.isArray(value)) return value.map((item) => resolveLiteral(item, context));
-  if (!isPlainObject(value)) return value;
-  if (isDateLiteral(value)) {
-    const time = resolveDate(value.$date, context.now);
-    if (Number.isNaN(time)) throw new JqlError(`${JSON.stringify(value.$date)} is not a date`);
+  if (!chunk74QKHM6Y_cjs.isPlainObject(value)) return value;
+  if (chunk74QKHM6Y_cjs.isDateLiteral(value)) {
+    const time = chunk74QKHM6Y_cjs.resolveDate(value.$date, context.now);
+    if (Number.isNaN(time)) throw new chunk74QKHM6Y_cjs.JqlError(`${JSON.stringify(value.$date)} is not a date`);
     return { $date: time };
   }
   const out = {};
@@ -2452,7 +536,7 @@ async function* iterate(source) {
   for (let i = 0; i < list.length; i++) yield list[i];
 }
 async function* filterStream(source, query, options) {
-  const test = compile(query, options);
+  const test = chunk2ZMIVDES_cjs.compile(query, options);
   for await (const item of iterate(source)) if (test(item)) yield item;
 }
 async function findAsync(source, query, options) {
@@ -2466,22 +550,22 @@ async function filterAsync(source, query, options) {
 }
 async function countAsync(source, query, options) {
   let total = 0;
-  const test = compile(query, options);
+  const test = chunk2ZMIVDES_cjs.compile(query, options);
   for await (const item of iterate(source)) if (test(item)) total++;
   return total;
 }
 async function someAsync(source, query, options) {
-  const test = compile(query, options);
+  const test = chunk2ZMIVDES_cjs.compile(query, options);
   for await (const item of iterate(source)) if (test(item)) return true;
   return false;
 }
 async function everyAsync(source, query, options) {
-  const test = compile(query, options);
+  const test = chunk2ZMIVDES_cjs.compile(query, options);
   for await (const item of iterate(source)) if (!test(item)) return false;
   return true;
 }
 async function searchAsync(source, request = {}, options = {}) {
-  const plan2 = planRequest(request, options);
+  const plan2 = chunk2ZMIVDES_cjs.planRequest(request, options);
   const collect2 = plan2.collect();
   let index = 0;
   for await (const item of iterate(source)) {
@@ -2492,38 +576,101 @@ async function searchAsync(source, request = {}, options = {}) {
   return plan2.shape(collect2.finish());
 }
 
-exports.DEFAULT_LIMITS = DEFAULT_LIMITS;
-exports.FIELD_OPERATORS = FIELD_OPERATORS;
-exports.JqlError = JqlError;
-exports.QUERY_OPERATORS = QUERY_OPERATORS;
-exports.UNTRUSTED_LIMITS = UNTRUSTED_LIMITS;
+Object.defineProperty(exports, "DEFAULT_LIMITS", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.DEFAULT_LIMITS; }
+});
+Object.defineProperty(exports, "FIELD_OPERATORS", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.FIELD_OPERATORS; }
+});
+Object.defineProperty(exports, "QUERY_OPERATORS", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.QUERY_OPERATORS; }
+});
+Object.defineProperty(exports, "UNTRUSTED_LIMITS", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.UNTRUSTED_LIMITS; }
+});
+Object.defineProperty(exports, "compile", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.compile; }
+});
+Object.defineProperty(exports, "count", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.count; }
+});
+Object.defineProperty(exports, "every", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.every; }
+});
+Object.defineProperty(exports, "filter", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.filter; }
+});
+Object.defineProperty(exports, "filterMap", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.filterMap; }
+});
+Object.defineProperty(exports, "filterRecord", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.filterRecord; }
+});
+Object.defineProperty(exports, "find", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.find; }
+});
+Object.defineProperty(exports, "findEntry", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.findEntry; }
+});
+Object.defineProperty(exports, "findIndex", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.findIndex; }
+});
+Object.defineProperty(exports, "matches", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.matches; }
+});
+Object.defineProperty(exports, "partition", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.partition; }
+});
+Object.defineProperty(exports, "search", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.search; }
+});
+Object.defineProperty(exports, "some", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.some; }
+});
+Object.defineProperty(exports, "untyped", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.untyped; }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () { return chunk2ZMIVDES_cjs.validate; }
+});
+Object.defineProperty(exports, "defineVocabulary", {
+  enumerable: true,
+  get: function () { return chunkEJFHVGBC_cjs.defineVocabulary; }
+});
+Object.defineProperty(exports, "JqlError", {
+  enumerable: true,
+  get: function () { return chunk74QKHM6Y_cjs.JqlError; }
+});
 exports.canonical = canonical;
-exports.compile = compile;
-exports.count = count2;
 exports.countAsync = countAsync;
-exports.defineVocabulary = defineVocabulary;
-exports.every = every;
 exports.everyAsync = everyAsync;
 exports.explain = explain;
-exports.filter = filter;
 exports.filterAsync = filterAsync;
-exports.filterMap = filterMap;
-exports.filterRecord = filterRecord;
 exports.filterStream = filterStream;
-exports.find = find;
 exports.findAsync = findAsync;
-exports.findEntry = findEntry;
-exports.findIndex = findIndex;
 exports.fingerprint = fingerprint;
 exports.group = group;
-exports.matches = matches;
-exports.partition = partition;
 exports.plan = plan;
-exports.search = search;
 exports.searchAsync = searchAsync;
-exports.some = some;
 exports.someAsync = someAsync;
-exports.untyped = untyped;
-exports.validate = validate;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map