@osqd/jql 0.1.1

package/dist/index.cjs

@@ -0,0 +1,2529 @@
+'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;
+}
+
+// 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 (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");
+  }
+  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");
+  }
+  const reach = reachField(by, checkVocabulary(options.vocabulary), "by");
+  const test = options.where === void 0 ? void 0 : 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 = [];
+  const visit = (item) => {
+    if (test !== void 0 && !test(item)) return;
+    keys.length = 0;
+    reach(item, (value) => {
+      collect(value, keys);
+      return false;
+    });
+    for (const key of keys) {
+      let held = groups.get(key);
+      if (held === void 0) {
+        held = { key, count: 0, items: [] };
+        groups.set(key, held);
+      }
+      held.count++;
+      if (held.items.length < keep) held.items.push(item);
+    }
+  };
+  if (Array.isArray(source)) for (let i = 0; i < source.length; i++) visit(source[i]);
+  else if (source instanceof Map) for (const item of source.values()) visit(item);
+  else if (typeof source[Symbol.iterator] === "function") for (const item of source) visit(item);
+  else {
+    const list = source;
+    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 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 });
+}
+function collect(value, into) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      if (!into.includes(null)) into.push(null);
+      return;
+    }
+    for (const element of value) collect(element, into);
+    return;
+  }
+  const key = value === void 0 || value === null || typeof value === "object" ? null : value;
+  if (!into.includes(key)) into.push(key);
+}
+
+// src/explain.ts
+var FIELD_OPERATOR_SET2 = new Set(FIELD_OPERATORS);
+function explain(query, item, options = {}) {
+  return node(query, item, "", options);
+}
+function matchedBy(clause, item, options) {
+  return compile(clause, options)(item);
+}
+function node(clause, item, at, options) {
+  if (typeof clause === "function" || !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 rest = keys.filter((key2) => !self.includes(key2));
+    const parts = rest.map((key2) => node({ [key2]: clause[key2] }, item, at, options));
+    if (self.length > 0) {
+      const whole = {};
+      for (const key2 of self) whole[key2] = clause[key2];
+      parts.push(leaf(whole, item, at, options, self[0]));
+    }
+    return branch(clause, at, parts, "and");
+  }
+  const key = keys[0];
+  const value = clause[key];
+  const here = join2(at, key);
+  switch (key) {
+    case "$and":
+    case "$or":
+    case "$nor": {
+      if (!Array.isArray(value)) break;
+      const parts = value.map((part, index) => node(part, item, `${here}[${index}]`, options));
+      return branch(clause, here, parts, key === "$and" ? "and" : key === "$or" ? "or" : "nor");
+    }
+    case "$not": {
+      const inner = node(value, item, here, options);
+      return {
+        matched: !inner.matched,
+        at: here,
+        clause,
+        because: inner.matched ? "what it negates holds" : "what it negates does not hold",
+        parts: [inner]
+      };
+    }
+  }
+  if (!key.startsWith("$") && isPlainObject(value) && !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));
+    return branch(clause, here, parts, "and");
+  }
+  return leaf(clause, item, here, options, key);
+}
+function branch(clause, at, parts, kind) {
+  const held = parts.filter((part) => part.matched).length;
+  const matched = kind === "and" ? held === parts.length : kind === "or" ? held > 0 : held === 0;
+  const many = parts.length === 1 ? "part" : "parts";
+  const because = kind === "nor" ? `${held} of ${parts.length} ${many} hold, and none may` : `${held} of ${parts.length} ${many} hold${kind === "or" ? ", and one is enough" : ""}`;
+  return { matched, at, clause, because, parts };
+}
+function leaf(clause, item, at, options, key) {
+  const matched = matchedBy(clause, item, options);
+  return { matched, at, clause, because: reason(clause, item, 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";
+  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) => {
+      if (found.length < 4) found.push(value);
+      return false;
+    });
+  } catch {
+    return "the clause was run as given";
+  }
+  return `${path} is ${values(found)}`;
+}
+function values(found) {
+  if (found.length === 0 || found.length === 1 && found[0] === void 0) return "missing";
+  const written = found.map((value) => value === void 0 ? "missing" : shorten(value));
+  return written.length === 1 ? written[0] : `each of ${written.join(", ")}`;
+}
+function shorten(value) {
+  if (value instanceof Date) return value.toISOString();
+  let text2;
+  try {
+    text2 = JSON.stringify(value) ?? String(value);
+  } catch {
+    return "a value that cannot be written out";
+  }
+  return text2.length > 60 ? `${text2.slice(0, 60)}\u2026` : text2;
+}
+function join2(at, key) {
+  return at === "" ? key : `${at}.${key}`;
+}
+
+// src/canonical.ts
+var SETS = /* @__PURE__ */ new Set(["$in", "$nin", "$all", "$contains", "$startsWith", "$endsWith", "$word", "$glob"]);
+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);
+  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;
+  const out = {};
+  const keys = Object.keys(value).sort().filter((key) => key !== "$comment");
+  const alone = keys.length === 1;
+  for (const key of keys) {
+    const held = value[key];
+    if (LOGIC.has(key) && Array.isArray(held)) {
+      const parts = flatten(key, held).map(rewrite).sort(byText);
+      if (parts.length === 1 && key !== "$nor" && alone) return parts[0];
+      out[key] = parts;
+      continue;
+    }
+    if (key === "$not") {
+      out[key] = rewrite(held);
+      continue;
+    }
+    if (key === "$text") {
+      out[key] = text(held);
+      continue;
+    }
+    if (key.startsWith("$")) {
+      out[key] = operand(key, held);
+      continue;
+    }
+    out[key] = condition(held);
+  }
+  return fold(out);
+}
+function fold(out) {
+  const parts = out.$and;
+  if (!Array.isArray(parts) || parts.length === 0) return out;
+  const taken = new Set(Object.keys(out).filter((key) => key !== "$and"));
+  const lifted = {};
+  const kept = [];
+  for (const part of parts) {
+    const keys = isPlainObject(part) ? Object.keys(part) : void 0;
+    if (keys === void 0 || keys.length === 0 || keys.some((key) => taken.has(key))) {
+      kept.push(part);
+      continue;
+    }
+    for (const key of keys) {
+      taken.add(key);
+      lifted[key] = part[key];
+    }
+  }
+  if (Object.keys(lifted).length === 0) return out;
+  const merged = { ...lifted };
+  for (const [key, value] of Object.entries(out)) if (key !== "$and") merged[key] = value;
+  if (kept.length > 0) merged.$and = kept;
+  const sorted = {};
+  for (const key of Object.keys(merged).sort()) sorted[key] = merged[key];
+  return sorted;
+}
+function condition(value) {
+  if (isPlainObject(value) && !isDateLiteral(value) && !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;
+  }
+  return { $eq: literal(value) };
+}
+function operand(key, value) {
+  if (SETS.has(key) && Array.isArray(value)) return unique(value.map(literal));
+  if (QUERIES.has(key)) return rewrite(value);
+  if (key === "$type" && Array.isArray(value)) {
+    const types = unique(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);
+  return literal(value);
+}
+function literal(value) {
+  if (Array.isArray(value)) return value.map(literal);
+  if (!isPlainObject(value) || isDateLiteral(value) || 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;
+  if (search2 === void 0) return value;
+  const out = { $search: search2.$search };
+  if (Array.isArray(search2.$fields)) out.$fields = unique(search2.$fields);
+  if (search2.$caseSensitive === true) out.$caseSensitive = true;
+  return out;
+}
+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;
+    if (Array.isArray(inner)) out.push(...flatten(key, inner));
+    else out.push(part);
+  }
+  return out;
+}
+function byText(a, b) {
+  const left = JSON.stringify(a) ?? "";
+  const right = JSON.stringify(b) ?? "";
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function unique(values2) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const value of values2) {
+    const written = JSON.stringify(value) ?? String(value);
+    if (!seen.has(written)) seen.set(written, value);
+  }
+  return [...seen.values()].sort(byText);
+}
+function checksum(text2) {
+  let low = 2166136261;
+  let high = 16777619;
+  for (let i = 0; i < text2.length; i++) {
+    const code = text2.charCodeAt(i);
+    low = Math.imul(low ^ code, 16777619) >>> 0;
+    high = Math.imul(high ^ code + i, 2246822507) >>> 0;
+  }
+  return low.toString(16).padStart(8, "0") + high.toString(16).padStart(8, "0");
+}
+
+// src/plan.ts
+var KNOWN = /* @__PURE__ */ new Set([...FIELD_OPERATORS, ...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);
+  if (!verdict.valid) throw verdict.error;
+  const now = options.now === void 0 ? Date.now() : options.now();
+  const vocabulary = options.vocabulary;
+  const fields = capabilities.fields ?? "all";
+  const operators = capabilities.operators ?? "all";
+  const context = {
+    vocabulary,
+    now,
+    fields: fields === "all" ? "all" : new Set(fields),
+    operators: operators === "all" ? "all" : new Set(operators),
+    or: capabilities.or ?? false,
+    not: capabilities.not ?? false,
+    accepts: capabilities.accepts
+  };
+  const pushed = [];
+  const stays = [];
+  const kept = [];
+  for (const { clause, at } of conjuncts(query, "")) {
+    const why = unpushable(clause, context);
+    if (why === void 0) pushed.push(resolve(clause, context));
+    else {
+      stays.push(clause);
+      kept.push({ at, clause, why });
+    }
+  }
+  return {
+    pushed: join3(pushed),
+    remaining: join3(stays),
+    complete: stays.length === 0,
+    kept
+  };
+}
+function conjuncts(query, at) {
+  const out = [];
+  for (const [key, value] of Object.entries(query)) {
+    const here = at === "" ? key : `${at}.${key}`;
+    if (key === "$comment") continue;
+    if (key === "$and" && Array.isArray(value)) {
+      value.forEach((part, index) => {
+        if (isPlainObject(part)) out.push(...conjuncts(part, `${here}[${index}]`));
+      });
+      continue;
+    }
+    out.push({ clause: { [key]: value }, at: here });
+  }
+  return out;
+}
+function join3(parts) {
+  if (parts.length === 0) return void 0;
+  const query = parts.length === 1 ? parts[0] : { $and: parts };
+  return query;
+}
+function unpushable(clause, context, at) {
+  for (const [key, value] of Object.entries(clause)) {
+    if (key.startsWith("$")) {
+      const why2 = unpushableOperator(key, value, context);
+      if (why2 !== void 0) return why2;
+      continue;
+    }
+    const why = unpushableField(key, value, context);
+    if (why !== void 0) return why;
+  }
+  return void 0;
+}
+function unpushableOperator(key, value, context, at) {
+  switch (key) {
+    case "$and":
+      if (!Array.isArray(value)) return "the clause is malformed";
+      for (const part of value) {
+        if (!isPlainObject(part)) return "the clause is malformed";
+        const why = unpushable(part, context);
+        if (why !== void 0) return why;
+      }
+      return void 0;
+    case "$or":
+    case "$nor": {
+      if (!context.or && key === "$or") return "the store cannot answer an $or";
+      if (!context.not && key === "$nor") return "the store cannot answer a negation";
+      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";
+        const why = unpushable(part, context);
+        if (why !== void 0) return why;
+      }
+      return void 0;
+    }
+    case "$not": {
+      if (!context.not) return "the store cannot answer a negation";
+      if (!isPlainObject(value)) return "the clause is malformed";
+      return unpushable(value, context);
+    }
+    case "$text":
+      return allows(context, "$text") ? void 0 : "the store cannot answer a text search";
+    default:
+      return `the store cannot test the item itself with "${key}"`;
+  }
+}
+function unpushableField(name, value, context, at) {
+  const field = context.vocabulary?.lookup.get(name.toLowerCase());
+  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 (!allows(context, "$eq")) return 'the store cannot answer "$eq"';
+    return accepted(context, stored, { $eq: value });
+  }
+  const keys = Object.keys(value);
+  if (!keys.every((key) => key.startsWith("$"))) {
+    if (!allows(context, "$eq")) return 'the store cannot answer "$eq"';
+    return accepted(context, stored, { $eq: value });
+  }
+  for (const key of keys) {
+    if (key === "$options" || key === "$comment") continue;
+    if (!KNOWN.has(key)) return `"${key}" is an added operator, which only this engine has`;
+    if (!allows(context, key)) return `the store cannot answer "${key}"`;
+    if ((key === "$ne" || key === "$nin" || key === "$not" || key === "$exists" && value[key] === false) && !context.not) {
+      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 (key === "$elemMatch") {
+      if (!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";
+      const why = unpushableField(name, operand2, context);
+      if (why !== void 0) return why;
+    }
+  }
+  return accepted(context, stored, value);
+}
+function accepted(context, field, condition2) {
+  if (context.accepts === void 0 || context.accepts(field, condition2)) return void 0;
+  return "the store cannot answer this condition's values";
+}
+function allows(context, operator) {
+  return context.operators === "all" || context.operators.has(operator);
+}
+function resolve(value, context) {
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [key, held] of Object.entries(value)) {
+    switch (key) {
+      case "$and":
+      case "$or":
+      case "$nor":
+        out[key] = Array.isArray(held) ? held.map((part) => resolve(part, context)) : held;
+        break;
+      case "$not":
+        out[key] = resolve(held, context);
+        break;
+      case "$text":
+        out[key] = resolveText(held, context);
+        break;
+      default:
+        if (key.startsWith("$")) out[key] = resolveOperand(key, held, context);
+        else out[storedName(key, context)] = resolveCondition(held, context);
+        break;
+    }
+  }
+  return out;
+}
+function resolveCondition(value, context) {
+  if (!isPlainObject(value)) return resolveLiteral(value, context);
+  if (isDateLiteral(value) || 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 = {};
+  for (const key of keys) out[key] = resolveOperand(key, value[key], context);
+  return out;
+}
+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));
+  return resolveLiteral(operand2, context);
+}
+function resolveText(value, context) {
+  if (!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`);
+    return { $date: time };
+  }
+  const out = {};
+  for (const [key, held] of Object.entries(value)) out[key] = resolveLiteral(held, context);
+  return out;
+}
+function storedName(key, context) {
+  if (key.startsWith("$") || context.vocabulary === void 0) return key;
+  const field = context.vocabulary.lookup.get(key.toLowerCase());
+  if (field !== void 0) return field.path;
+  const dot = key.indexOf(".");
+  if (dot > 0) {
+    const head = context.vocabulary.lookup.get(key.slice(0, dot).toLowerCase());
+    if (head !== void 0 && head.get === void 0) return `${head.path}${key.slice(dot)}`;
+  }
+  return key;
+}
+
+// src/async.ts
+async function* iterate(source) {
+  if (Array.isArray(source)) {
+    for (let i = 0; i < source.length; i++) yield source[i];
+    return;
+  }
+  if (source instanceof Map) {
+    for (const item of source.values()) yield item;
+    return;
+  }
+  if (typeof source[Symbol.asyncIterator] === "function") {
+    for await (const item of source) yield item;
+    return;
+  }
+  if (typeof source[Symbol.iterator] === "function") {
+    for (const item of source) yield item;
+    return;
+  }
+  const list = source;
+  for (let i = 0; i < list.length; i++) yield list[i];
+}
+async function* filterStream(source, query, options) {
+  const test = compile(query, options);
+  for await (const item of iterate(source)) if (test(item)) yield item;
+}
+async function findAsync(source, query, options) {
+  for await (const item of filterStream(source, query, options)) return item;
+  return void 0;
+}
+async function filterAsync(source, query, options) {
+  const out = [];
+  for await (const item of filterStream(source, query, options)) out.push(item);
+  return out;
+}
+async function countAsync(source, query, options) {
+  let total = 0;
+  const test = 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);
+  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);
+  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 collect2 = plan2.collect();
+  let index = 0;
+  for await (const item of iterate(source)) {
+    const position = index++;
+    if (plan2.test !== void 0 && !plan2.test(item)) continue;
+    if (collect2.offer(item, position)) break;
+  }
+  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;
+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