@osqd/jql 0.1.1

package/dist/global.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/internal/closest.ts","../src/internal/path.ts","../src/internal/duration.ts","../src/internal/values.ts","../src/limits.ts","../src/internal/equal.ts","../src/internal/glob.ts","../src/operators.ts","../src/vocabulary.ts","../src/core.ts","../src/internal/record.ts","../src/collections.ts","../src/internal/order.ts","../src/search.ts","../src/array.ts","../src/global.ts"],"names":["count","size","present","segment","walk","reach","search","i","changed"],"mappings":"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","file":"global.cjs","sourcesContent":["/**\n * The one way a query is refused.\n *\n * A query that looks right and matches nothing is the failure this library exists to\n * prevent: a misspelt operator, a field value that is `undefined` because a variable was,\n * a regex that does not compile. Each of those used to be a filter that silently let\n * everything through or nothing through, and nobody could tell which from the result. So\n * `compile` refuses, with a sentence saying what was wrong and where in the query it was.\n */\nexport class JqlError extends Error {\n  /**\n   * Where in the query the problem is, written the way you would reach it in code:\n   * `$or[1].age.$gt`. Empty for the query as a whole.\n   */\n  readonly at: string;\n\n  constructor(message: string, at = \"\") {\n    super(at === \"\" ? message : `at ${show(at)}: ${message}`);\n    this.name = \"JqlError\";\n    this.at = at;\n  }\n}\n\n/**\n * The location, short enough to read.\n *\n * A location is built from the query's own field names, and a field name is a string from\n * outside — a long one makes the sentence it prefixes unreadable, and turns a log line into\n * a paragraph. `at` itself keeps the whole path, because that is the part a program reads.\n */\nfunction show(at: string): string {\n  return at.length > 80 ? `${at.slice(0, 80)}…` : at;\n}\n","/**\n * \"Did you mean\" for names that almost exist.\n *\n * An unknown operator is refused either way; naming the one that was probably meant turns\n * a lookup in the documentation into a one-character fix.\n */\nexport function closest(word: string, candidates: Iterable<string>): string | undefined {\n  let best: string | undefined;\n  // Two edits is the line between a typo and a different word: `$gtt` → `$gt` is one,\n  // `$foo` → `$not` is two and is still more likely a slip than a new idea.\n  let bestDistance = 3;\n  for (const candidate of candidates) {\n    const distance = editDistance(word.toLowerCase(), candidate.toLowerCase(), bestDistance);\n    if (distance < bestDistance) {\n      best = candidate;\n      bestDistance = distance;\n    }\n  }\n  return best;\n}\n\n/** Levenshtein distance, giving up once it is certain to exceed `ceiling`. */\nfunction editDistance(a: string, b: string, ceiling: number): number {\n  if (Math.abs(a.length - b.length) >= ceiling) return ceiling;\n  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);\n  for (let i = 1; i <= a.length; i++) {\n    const current = [i];\n    let rowBest = i;\n    for (let j = 1; j <= b.length; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      const value = Math.min((previous[j] as number) + 1, (current[j - 1] as number) + 1, (previous[j - 1] as number) + cost);\n      current.push(value);\n      if (value < rowBest) rowBest = value;\n    }\n    if (rowBest >= ceiling) return ceiling;\n    previous = current;\n  }\n  return previous[b.length] as number;\n}\n\n/** The suffix of an error sentence that offers the likely name, or nothing. */\nexport function didYouMean(word: string, candidates: Iterable<string>): string {\n  const guess = closest(word, candidates);\n  return guess === undefined ? \"\" : `; did you mean \"${guess}\"?`;\n}\n","/**\n * Reaching a field inside a document.\n *\n * A path is dot-separated: `address.city`, `items.id`, `items.0.id`. Three rules:\n *\n * - **An array is seen through.** `items.id` reaches the `id` of every element, and a\n *   condition on it holds when it holds for any of them.\n * - **A numeric segment on an array is a position.** `items.0.id` is the first element's.\n * - **A `Map` is read by key**, so a document that keeps a lookup table in a `Map` can be\n *   queried the same way as one that keeps it in an object.\n *\n * Only own properties are read. `{ constructor: { $exists: true } }` would otherwise match\n * every object ever made, and `__proto__` would reach somewhere a query has no business\n * being. The check costs a `hasOwn` call, so it is paid only for the handful of names\n * `Object.prototype` and `Map.prototype` actually have — every other name is read\n * directly. `Map.prototype` is on the list because a `Map` document read directly would\n * answer `size` or `get` with its own method rather than with the entry of that name.\n */\n\n/**\n * Calls `test` with each value the path reaches, stopping at the first `true`.\n *\n * A path that reaches nothing calls `test(undefined)` once, so \"missing\" is a value a\n * condition can ask about: that is how `{ field: null }` and `$exists: false` see it.\n */\nexport type Reach = (document: unknown, test: (value: unknown) => boolean) => boolean;\n\n/** A single-valued read, for paths that cannot fan out. Absent when the path can. */\nexport type Read = (document: unknown) => unknown;\n\n/** What a probe returns when the path met an array before its last segment, and so may reach several values. */\nexport const FANOUT: unique symbol = Symbol(\"jql.fanout\");\n\n/**\n * A straight read of a multi-segment path: the one value it reaches, or `FANOUT` if an\n * array stood in the way and only `Reach` can answer.\n *\n * The point is the common case. `address.city` on a record with no arrays on the way has\n * exactly one value, and reading it directly lets the engine test it the way a hand-written\n * `p.address.city === \"x\"` would — one read, one comparison — instead of through a walk and\n * a callback. A missing or primitive step reads as `undefined`, the same as `Reach` sees it.\n */\nexport type Probe = (document: unknown) => unknown;\n\ninterface Segment {\n  readonly key: string;\n  /** The position this segment names on an array, or -1. */\n  readonly index: number;\n}\n\nconst INDEX = /^(?:0|[1-9]\\d{0,8})$/;\n\n/**\n * The names a plain object inherits, which are therefore the only ones a direct read can\n * find on one by accident.\n */\nconst INHERITED = new Set<string>([...Object.getOwnPropertyNames(Object.prototype), ...Object.getOwnPropertyNames(Map.prototype), \"__proto__\"]);\n\n/** Whether a name could be found on a plain object's prototype, and so must always be asked for carefully. */\nexport function needsGuard(key: string): boolean {\n  return INHERITED.has(key);\n}\n\n/**\n * What a plain object's prototype is, for the cheapest plainness test there is.\n *\n * `document.__proto__ === PLAIN` is a map check — about as fast as reading a field — where\n * `Object.getPrototypeOf` is a call and `Object.hasOwn` is a second lookup. Reading it is\n * safe in both directions: a document carrying its own `__proto__` field (which is what\n * `JSON.parse` makes of one) simply fails the test and takes the careful path, and so does\n * anything with a prototype of its own.\n */\nexport const PLAIN = Object.prototype;\n\nfunction segment(key: string): Segment {\n  return { key, index: INDEX.test(key) ? Number(key) : -1 };\n}\n\n/**\n * One field of one value: own properties and `Map` entries, nothing else.\n *\n * Ownership is checked **before** the read, not after, and for every name rather than for a\n * list of known-inherited ones. The list was only ever `Object.prototype` and\n * `Map.prototype`, so a document that was a class instance answered `{ role: \"admin\" }` from\n * its prototype — and `{ secret: … }` by *running* an inherited getter, which is a query\n * executing code the document's author wrote. Asking first is also why no accessor outside\n * the item can run at all.\n */\nexport function readOwn(value: object, key: string): unknown {\n  if (value instanceof Map) return value.get(key);\n  return Object.hasOwn(value, key) ? (value as Record<string, unknown>)[key] : undefined;\n}\n\nfunction readOne(value: object, step: Segment): unknown {\n  return readOwn(value, step.key);\n}\n\n/**\n * The value at a single-segment path.\n *\n * The overwhelmingly common case — `{ id: 2 }` — so it is written out: a direct property\n * read, with the `Map` check paid only when the read found nothing, which a plain object\n * with the field never does.\n */\nexport function readKey(key: string): Read {\n  return (document) => (document !== null && typeof document === \"object\" ? readOwn(document, key) : undefined);\n}\n\n/** The whole document, for queries that are conditions on the value itself. */\nexport const readSelf: Read = (document) => document;\n\n/**\n * Builds the walk for a multi-segment path.\n *\n * A loop while the path meets only objects, which is nearly always, and the recursive\n * fan-out only from the first array it meets. `address.city` on a record with no arrays in\n * it costs two property reads and one call.\n */\nexport function reachPath(keys: readonly string[]): Reach {\n  const steps = keys.map(segment);\n  return (document, test) => {\n    let value = document;\n    for (let at = 0; at < steps.length; at++) {\n      if (value === null || typeof value !== \"object\") return test(undefined);\n      if (Array.isArray(value)) return walk(value, steps, at, test);\n      value = readOne(value, steps[at] as Segment);\n    }\n    return test(value);\n  };\n}\n\n/** Builds the straight read for a multi-segment path. */\nexport function probePath(keys: readonly string[]): Probe {\n  const steps = keys.map(segment);\n  const last = steps.length - 1;\n  const [first, second] = steps as [Segment, Segment];\n  if (steps.length === 1 && first.index === -1) {\n    // One segment, which is nearly every query: one read, and `FANOUT` where the item is\n    // itself an array, because an array is seen through at every segment including the first.\n    const only = first.key;\n    const guarded = needsGuard(only);\n    return (document) => {\n      if (document === null || typeof document !== \"object\") return undefined;\n      if (Array.isArray(document)) return FANOUT;\n      // Written out rather than calling `readOwn`: the call costs about as much as the work\n      // it does, and this runs once per document per field.\n      if (!guarded && (document as { __proto__?: unknown }).__proto__ === PLAIN) return (document as Record<string, unknown>)[only];\n      return readOwn(document, only);\n    };\n  }\n  if (steps.length === 2 && first.index === -1 && second.index === -1) {\n    // `a.b`, the shape nearly every nested field has, written out: two reads, no loop.\n    const outer = first.key;\n    const inner = second.key;\n    const outerGuarded = needsGuard(outer);\n    const innerGuarded = needsGuard(inner);\n    return (document) => {\n      if (document === null || typeof document !== \"object\") return undefined;\n      if (Array.isArray(document)) return FANOUT;\n      const value =\n        !outerGuarded && (document as { __proto__?: unknown }).__proto__ === PLAIN ? (document as Record<string, unknown>)[outer] : readOwn(document, outer);\n      if (value === null || typeof value !== \"object\") return undefined;\n      if (Array.isArray(value)) return FANOUT;\n      return !innerGuarded && (value as { __proto__?: unknown }).__proto__ === PLAIN ? (value as Record<string, unknown>)[inner] : readOwn(value, inner);\n    };\n  }\n  return (document) => {\n    let value = document;\n    for (let at = 0; at <= last; at++) {\n      if (value === null || typeof value !== \"object\") return undefined;\n      if (Array.isArray(value) && (steps[at] as Segment).index === -1) return FANOUT;\n      const step = steps[at] as Segment;\n      value = Array.isArray(value) ? value[step.index] : readOwn(value, step.key);\n    }\n    return value;\n  };\n}\n\n/** The same, from a value some other accessor produced. */\nexport function probeFrom(read: Read, keys: readonly string[]): Probe {\n  const probe = probePath(keys);\n  return (document) => probe(read(document));\n}\n\n/** Continues a walk from a value some other accessor produced. */\nexport function reachFrom(read: Read, keys: readonly string[]): Reach {\n  const steps = keys.map(segment);\n  return (document, test) => walk(read(document), steps, 0, test);\n}\n\n/**\n * How deep a document may nest before a path stops descending.\n *\n * Every other walk in this library is bounded — the text search by its own limit, equality\n * and sorting by theirs — and this one was not, so a document holding ten thousand nested\n * arrays threw a `RangeError` out of the predicate. That is reachable from a JSON body,\n * whose parser has no such limit, and it aborts a whole scan over one row. Past the cap the\n * value is treated as missing, which is what a path that cannot reach something means\n * everywhere else.\n */\nconst MAX_DOCUMENT_DEPTH = 512;\n\nfunction walk(value: unknown, steps: readonly Segment[], at: number, test: (value: unknown) => boolean, depth = 0): boolean {\n  if (at === steps.length) return test(value);\n  if (value === null || typeof value !== \"object\" || depth > MAX_DOCUMENT_DEPTH) return test(undefined);\n  const step = steps[at] as Segment;\n  if (Array.isArray(value)) {\n    if (step.index !== -1) return walk(value[step.index], steps, at + 1, test, depth + 1);\n    // Fan out: the same segment, applied to each element.\n    if (value.length === 0) return test(undefined);\n    for (let i = 0; i < value.length; i++) if (walk(value[i], steps, at, test, depth + 1)) return true;\n    return false;\n  }\n  return walk(readOne(value, step), steps, at + 1, test, depth + 1);\n}\n\n/**\n * How many segments a path may have.\n *\n * The same number as the document depth above, and for the same reason: a path longer than\n * the deepest document a walk will follow can reach nothing anyway, so refusing it costs a\n * query nothing real. What it buys is two things. A field name is the one part of a query\n * whose size the node count does not bound — `{\"a.a.a…\": 1}` is a single node however long\n * it is — and each segment becomes an object and a step in a walk, so a field name pasted\n * from somewhere could turn a small query into a large one.\n *\n * And it makes the same path mean the same thing everywhere. Projection walked its own tree\n * of segments and stopped at sixty-four, silently, so a query matched on a path that\n * `fields` then dropped from the result: the filter and the projection disagreed about a\n * path they were both given.\n */\nexport const MAX_PATH_SEGMENTS = 512;\n\n/**\n * Splits a field name into segments, refusing the ones that can reach nothing.\n *\n * Returns the reason as a sentence for the caller to raise, so this module stays free of\n * the error type and its location bookkeeping.\n */\nexport function splitPath(path: string): string[] | string {\n  if (path === \"\") return \"an empty field name reaches nothing\";\n  const keys = path.split(\".\");\n  if (keys.length > MAX_PATH_SEGMENTS) {\n    return `the path has ${keys.length} segments, past the limit of ${MAX_PATH_SEGMENTS}; nothing nests that deep`;\n  }\n  // The path is shown shortened: it is a string from outside, and one long enough to be\n  // worth refusing is long enough to bury the sentence explaining why.\n  for (const key of keys) if (key === \"\") return `the path \"${path.length > 80 ? `${path.slice(0, 80)}…` : path}\" has an empty segment, which reaches nothing`;\n  return keys;\n}\n","/**\n * Durations, for the relative dates a saved filter is written with.\n *\n * `\"1h\"`, `\"30m\"`, `\"1h30m\"`, `\"7d\"`. Written as one or more counts with a unit, largest\n * first by convention but in any order, because a filter is typed by a person and\n * `\"30m1h\"` means what it says.\n *\n * Months and years are deliberately absent: neither has a fixed length, so `\"1mo\"` would\n * mean something slightly different in February, and a filter whose window changes size\n * with the calendar is one nobody can reason about. Use days or weeks.\n */\n\nconst PART = /(\\d+)(ms|s|m|h|d|w)/g;\nconst SHAPE = /^(?:\\d+(?:ms|s|m|h|d|w))+$/;\n\nconst UNITS: Readonly<Record<string, number>> = {\n  ms: 1,\n  s: 1_000,\n  m: 60_000,\n  h: 3_600_000,\n  d: 86_400_000,\n  w: 604_800_000,\n};\n\n/** The unit names, for an error that says what is accepted. */\nexport const DURATION_UNITS = Object.keys(UNITS);\n\n/** A duration in milliseconds, or `undefined` when the text is not one. */\nexport function parseDuration(text: string): number | undefined {\n  if (!SHAPE.test(text)) return undefined;\n  let total = 0;\n  PART.lastIndex = 0;\n  for (;;) {\n    const part = PART.exec(text);\n    if (part === null) break;\n    const count = Number(part[1]);\n    // A count that does not survive the round trip through a number is not a duration\n    // anybody meant; it is a digit string long enough to have lost its tail.\n    if (!Number.isSafeInteger(count)) return undefined;\n    total += count * (UNITS[part[2] as string] as number);\n  }\n  return Number.isSafeInteger(total) ? total : undefined;\n}\n","import { parseDuration } from \"./duration.js\";\nimport type { DateLiteral, FieldReference, TypeName } from \"../types.js\";\n\n/** An object literal or a JSON-parsed object: what a query document is made of. */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n\n/** `{ $date: … }` and nothing else. */\nexport function isDateLiteral(value: unknown): value is DateLiteral {\n  if (!isPlainObject(value) || !(\"$date\" in value)) return false;\n  for (const key in value) if (key !== \"$date\") return false;\n  return true;\n}\n\n/** `{ $field: \"path\" }` and nothing else: a comparison with another field of the same item. */\nexport function isFieldReference(value: unknown): value is FieldReference {\n  if (!isPlainObject(value) || typeof value.$field !== \"string\") return false;\n  for (const key in value) if (key !== \"$field\") return false;\n  return true;\n}\n\n/**\n * The instant a `$date` literal stands for, in epoch milliseconds, or `NaN`.\n *\n * `now` is passed in rather than read here, because a query holding `{ \"$ago\": \"1h\" }` has\n * to resolve against one instant for the whole run: reading the clock per comparison would\n * let the window move while a scan is in progress, so two items a second apart could be\n * judged against different hours. It is also what makes a relative filter testable without\n * waiting.\n */\nexport function resolveDate(value: unknown, now: number): number {\n  if (typeof value === \"number\") return value;\n  if (typeof value === \"string\") return value === \"now\" ? now : instant(value);\n  if (isPlainObject(value)) {\n    const keys = Object.keys(value);\n    if (keys.length !== 1) return Number.NaN;\n    const amount = keys[0] === \"$ago\" || keys[0] === \"$ahead\" ? value[keys[0] as string] : undefined;\n    if (typeof amount !== \"string\") return Number.NaN;\n    const span = parseDuration(amount);\n    if (span === undefined) return Number.NaN;\n    return keys[0] === \"$ago\" ? now - span : now + span;\n  }\n  return Number.NaN;\n}\n\n/**\n * A document value read as a date, in epoch milliseconds, or `NaN`.\n *\n * Only called where the query supplied a `$date`, so a string is only ever parsed as a\n * date because somebody asked for that. `NaN` compares false with everything, which is\n * what a value that is not a date should do.\n */\n/**\n * The forms of a date a document may hold, per the specification: a `Date`, epoch\n * milliseconds, or an **ISO 8601** string.\n *\n * `Date.parse` accepts a great deal more than that — `\"12/31/2020\"`, `\"Mar 5 2021\"`, and\n * `\"5\"`, which it reads as a year — and what it accepts beyond ISO 8601 is left to the\n * implementation by the language it comes from. A document that matched here and nowhere\n * else would make the same query mean different things in different engines, which is the\n * one thing this language promises it does not do. The space instead of `T` is allowed\n * because RFC 3339 allows it and people write it.\n */\nconst ISO_8601 = /^\\d{4}-\\d{2}-\\d{2}(?:[T ]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?(?:Z|[+-]\\d{2}:?\\d{2})?)?$/;\n\n/** A timestamp with a time and no offset, which is the one shape whose meaning is not fixed. */\nconst NO_OFFSET = /^(\\d{4}-\\d{2}-\\d{2})[T ](\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?)$/;\n\n/**\n * An instant from a string, read the same way on every machine.\n *\n * JavaScript reads a date-only string as midnight **UTC** and a timestamp with no offset as\n * **local time** — so `\"2026-01-01T12:00:00\"` was a different instant in Tokyo and in London,\n * and a query and a document that both held one answered differently depending on where the\n * process happened to be running. That is the failure the language already rules out for\n * `\"12/31/2020\"`: the same query meaning two things. A missing offset is UTC here, which is\n * the rule the date-only form already follows.\n */\nexport function instant(text: string): number {\n  const bare = NO_OFFSET.exec(text);\n  return bare === null ? Date.parse(text) : Date.parse(`${bare[1] as string}T${bare[2] as string}Z`);\n}\n\nexport function toTime(value: unknown): number {\n  if (typeof value === \"number\") return value;\n  if (value instanceof Date) return value.getTime();\n  if (typeof value === \"string\") return ISO_8601.test(value) ? instant(value) : Number.NaN;\n  return Number.NaN;\n}\n\n/** The type names `$type` knows, in one list, so the error for a wrong one can offer the right one. */\nexport const TYPE_NAMES: readonly TypeName[] = [\"string\", \"number\", \"integer\", \"bigint\", \"boolean\", \"null\", \"array\", \"object\", \"date\"];\n\n/** Whether a document value is of the named type. A missing value is of no type. */\nexport function isOfType(value: unknown, type: TypeName): boolean {\n  switch (type) {\n    case \"string\":\n      return typeof value === \"string\";\n    case \"number\":\n      // A big integer is a number for ordering, so it is one here too: `$gt` and `$type`\n      // disagreeing about the same value is a distinction nobody could explain.\n      return typeof value === \"number\" || typeof value === \"bigint\";\n    case \"integer\":\n      return Number.isInteger(value) || typeof value === \"bigint\";\n    case \"bigint\":\n      return typeof value === \"bigint\";\n    case \"boolean\":\n      return typeof value === \"boolean\";\n    case \"null\":\n      return value === null;\n    case \"array\":\n      return Array.isArray(value);\n    case \"date\":\n      return value instanceof Date;\n    case \"object\":\n      return value !== null && typeof value === \"object\" && !Array.isArray(value) && !(value instanceof Date);\n  }\n}\n\n/**\n * A readable name for a value in an error sentence.\n *\n * Specific about what it was given, because \"a query is an object, not an object\" — which\n * is what a `Map`, a `Set` and a class instance all used to produce — tells the reader\n * nothing at all about the thing they passed.\n */\nexport function describe(value: unknown): string {\n  if (value === null) return \"null\";\n  // Named rather than written out: `String(fn)` is the function's entire source, and a\n  // closure of any size turned the sentence refusing it into a listing.\n  if (typeof value === \"function\") return \"a function\";\n  if (Array.isArray(value)) return \"an array\";\n  if (value instanceof RegExp) return \"a RegExp object\";\n  if (value instanceof Date) return \"a Date object\";\n  if (value instanceof Map) return \"a Map\";\n  if (value instanceof Set) return \"a Set\";\n  if (typeof value === \"object\") {\n    if (isPlainObject(value)) return \"an object\";\n    const name = nameOf(value);\n    return name === undefined ? \"an object\" : `an instance of ${name}`;\n  }\n  if (typeof value === \"string\") return `the string ${JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value)}`;\n  return `${typeof value} ${String(value)}`;\n}\n\n/** The class an object came from, when it can be read without running anything of the caller's. */\nfunction nameOf(value: object): string | undefined {\n  const prototype = Object.getPrototypeOf(value) as { constructor?: { name?: unknown } } | null;\n  // Read from the prototype rather than through the object, so a `constructor` field of\n  // the caller's own — which a document or a query read from JSON can have — is not what\n  // names it.\n  const name = prototype?.constructor?.name;\n  return typeof name === \"string\" && name !== \"\" && name !== \"Object\" ? name : undefined;\n}\n","/**\n * How much of a query the engine will take.\n *\n * Queries arrive from places the caller does not control — a URL, a request body, a\n * saved filter somebody else wrote — and every limit here is a way such a query could\n * otherwise cost more than the data it filters. Each one refuses with a `JqlError` rather\n * than truncating, because a query that was quietly cut short answers a different\n * question from the one that was asked.\n *\n * The defaults are far past anything a person writes and far short of anything that\n * hurts. The caps are exported so a caller can say what it accepts in its own\n * documentation and refuse a query before it is even parsed.\n */\nexport interface Limits {\n  /** How deep operators may nest. Default 32: recursion over pasted input must stop well short of the stack. */\n  readonly maxDepth: number;\n  /** How many operators and fields a query may hold in total. Default 10 000. `$in` lists do not count: they cost one set lookup each. */\n  readonly maxNodes: number;\n  /** The longest `$regex` pattern. Default 1024. */\n  readonly maxPatternLength: number;\n  /**\n   * The longest `$glob`. Default 1024, and 256 for untrusted input.\n   *\n   * A glob cannot backtrack exponentially, but matching one holding `?` is the length of the\n   * pattern times the length of the value — so a megabyte of `?` against a megabyte of text\n   * is hours per document. It has a cap of its own because `$regex` is turned *off* for\n   * untrusted callers while `$glob` stays on, which is exactly when the cap has to hold.\n   */\n  readonly maxGlobLength: number;\n  /** How deep `$text` looks into a document. Default 16: past that a document is a graph, not a record. */\n  readonly maxTextDepth: number;\n  /**\n   * Which operators a query may use. Default `\"all\"`.\n   *\n   * An allowlist, because a public endpoint's answer to \"what may a caller ask?\" should be\n   * a list it wrote rather than everything the language grows later. `$text` walks a whole\n   * document and `$elemMatch` carries a query of its own; an endpoint that needs neither can\n   * say so once, here, instead of discovering later which of them somebody found.\n   *\n   * Names are checked when the query compiles: an operator outside the list is refused by\n   * name, never ignored. `$options` and `$comment` are exempt — they modify and annotate\n   * rather than ask anything — and `$field` counts as an operator, because comparing two\n   * fields is a capability in its own right.\n   */\n  readonly allowOperators: readonly string[] | \"all\";\n  /**\n   * Whether `$regex` is accepted at all. Default `true`.\n   *\n   * Turn it off for queries from untrusted callers. No engine can tell a pattern that\n   * backtracks for a minute from one that does not without running it, and the string\n   * operators (`$contains`, `$startsWith`, `$endsWith`, `$word`) answer almost every\n   * question a pattern would, in linear time.\n   */\n  readonly allowRegex: boolean;\n}\n\n/** The defaults, frozen, so they can be spread and never edited in place. */\nexport const DEFAULT_LIMITS: Readonly<Limits> = Object.freeze({\n  maxDepth: 32,\n  maxNodes: 10_000,\n  maxPatternLength: 1024,\n  maxGlobLength: 1024,\n  maxTextDepth: 16,\n  allowRegex: true,\n  allowOperators: \"all\",\n});\n\n/**\n * What an untrusted query gets: no patterns, and a tighter size.\n *\n * Public so a service taking queries from a URL can use the same answer as every other\n * service in the project, rather than each one picking its own numbers.\n */\nexport const UNTRUSTED_LIMITS: Readonly<Limits> = Object.freeze({\n  maxDepth: 16,\n  maxNodes: 512,\n  maxPatternLength: 0,\n  maxGlobLength: 256,\n  maxTextDepth: 8,\n  allowRegex: false,\n  // Still every operator but `$regex`: which of the rest an endpoint wants is a decision\n  // only that endpoint can make, and a list guessed here would be one nobody had chosen.\n  allowOperators: \"all\",\n});\n","import { isDateLiteral, isPlainObject, resolveDate, toTime } from \"./values.js\";\n\n/**\n * Equality between a document value and a query literal.\n *\n * Built once per literal rather than called generically, because the literal is known at\n * compile time and the document value is the only thing that changes: a primitive\n * literal becomes one `===`, and only an object or array literal pays for a walk.\n *\n * The rules, which the specification states and every implementation must share:\n * objects are equal when they have the same keys with equal values, **in any order**\n * (JSON does not promise key order, so a comparison that depended on it would depend on\n * whoever serialised the query); a key whose value is `undefined` counts as absent;\n * arrays are equal element by element, in order; a `$date` literal equals any value that\n * reads as the same instant.\n */\nexport type Equals = (value: unknown) => boolean;\n\n/** Whether a big integer and an ordinary number are the same whole number. */\nfunction sameInteger(a: unknown, b: unknown): boolean {\n  const big = typeof a === \"bigint\" ? a : typeof b === \"bigint\" ? b : undefined;\n  const other = typeof a === \"bigint\" ? b : a;\n  if (big === undefined) return false;\n  if (typeof other === \"bigint\") return big === other;\n  return typeof other === \"number\" && Number.isInteger(other) && big === BigInt(other);\n}\n\n/** How deep an object literal comparison walks. Past this the two are treated as different. */\nconst MAX_EQUAL_DEPTH = 64;\n\n/**\n * The same whole number as a big integer, when a literal is one and could be written either\n * way.\n *\n * Settled once, when the query compiles, so the comparison stays a single `===` against a\n * value prepared in advance. Only a whole number gets one: nothing is a big integer and a\n * fraction, and a string or a boolean can never be one either.\n */\nexport function alsoBig(literal: unknown): bigint | undefined {\n  return typeof literal === \"number\" && Number.isInteger(literal) ? BigInt(literal) : undefined;\n}\n\nexport function equalsLiteral(literal: unknown, now: number, ignoreCase = false): Equals {\n  if (literal === null) return (value) => value === null;\n  if (typeof literal !== \"object\") {\n    if (ignoreCase && typeof literal === \"string\") {\n      const wanted = literal.toLowerCase();\n      return (value) => typeof value === \"string\" && value.toLowerCase() === wanted;\n    }\n    // A big integer is a number everywhere else in the language: ordering puts `10n` and\n    // `10` in the same place, `$type` calls both numbers. Equality alone compared the two\n    // kinds with `===` and said no — so a document holding `10n` was at once `$gte: 10`,\n    // `$lte: 10` and `$ne: 10`, which is not a thing any value can be. A query cannot carry\n    // a big integer of its own (JSON has none, and one is refused), so a number is the only\n    // way to ask about such a value at all.\n    const big = alsoBig(literal);\n    if (big !== undefined) return (value) => value === literal || value === big;\n    return (value) => value === literal;\n  }\n  if (isDateLiteral(literal)) {\n    const time = resolveDate(literal.$date, now);\n    return (value) => toTime(value) === time;\n  }\n  return (value) => deepEqual(value, literal, 0, ignoreCase, now);\n}\n\n/**\n * Equality between two values that both came out of a document, for `$field` references.\n *\n * The same rules as equality with a literal — same type, arrays in order, objects in any\n * key order — but neither side is known when the query compiles, so nothing can be\n * prepared. Missing is not equal to anything, including itself: a reference that reaches\n * nothing matches nothing.\n */\nexport function valuesEqual(a: unknown, b: unknown): boolean {\n  if (a === undefined || b === undefined) return false;\n  if (a instanceof Date || b instanceof Date) {\n    const left = toTime(a);\n    const right = toTime(b);\n    return a instanceof Date && b instanceof Date && left === right && !Number.isNaN(left);\n  }\n  return deepEqual(a, b, 0);\n}\n\nfunction deepEqual(actual: unknown, wanted: unknown, depth: number, ignoreCase = false, now = 0): boolean {\n  if (actual === wanted) return true;\n  // The two kinds of number, one level down — and on both sides, because `valuesEqual`\n  // brings two document values here and either of them may be the big one.\n  if (typeof actual === \"bigint\" || typeof wanted === \"bigint\") return sameInteger(actual, wanted);\n  if (actual instanceof Date && wanted instanceof Date) return actual.getTime() === wanted.getTime();\n  if (depth > MAX_EQUAL_DEPTH) return false;\n  // Ignoring case is a rule about comparing strings, so it holds wherever a string is\n  // compared — including the ones inside a list or an object. Applied only to the literal's\n  // own top level, `{ $eq: \"A\", $options: \"i\" }` matched `\"a\"` while `{ $eq: [\"A\"], … }` did\n  // not match `[\"a\"]`, and nothing said why.\n  if (ignoreCase && typeof actual === \"string\" && typeof wanted === \"string\") return actual.toLowerCase() === wanted.toLowerCase();\n  if (wanted === null || typeof wanted !== \"object\") return false;\n  // `resolveDate`, not `toTime`: a `{ \"$ago\": … }` or `\"now\"` nested inside a list or an\n  // object was read by a function that knows neither, came out `NaN`, and quietly matched\n  // nothing — while the same literal written on its own worked.\n  if (isDateLiteral(wanted)) return toTime(actual) === resolveDate(wanted.$date, now);\n  if (actual === null || typeof actual !== \"object\") return false;\n  if (Array.isArray(wanted)) {\n    if (!Array.isArray(actual) || actual.length !== wanted.length) return false;\n    for (let i = 0; i < wanted.length; i++) if (!deepEqual(actual[i], wanted[i], depth + 1, ignoreCase, now)) return false;\n    return true;\n  }\n  if (Array.isArray(actual) || !isPlainObject(wanted)) return false;\n  if (actual instanceof Map) {\n    let size = 0;\n    for (const key in wanted) {\n      const expected = wanted[key];\n      if (expected === undefined) continue;\n      size++;\n      if (!actual.has(key) || !deepEqual(actual.get(key), expected, depth + 1, ignoreCase, now)) return false;\n    }\n    let present = 0;\n    for (const value of actual.values()) if (value !== undefined) present++;\n    return present === size;\n  }\n  const record = actual as Record<string, unknown>;\n  let size = 0;\n  for (const key in wanted) {\n    const expected = wanted[key];\n    if (expected === undefined) continue;\n    size++;\n    if (!Object.hasOwn(record, key) || !deepEqual(record[key], expected, depth + 1, ignoreCase, now)) return false;\n  }\n  let present = 0;\n  for (const key in record) if (Object.hasOwn(record, key) && record[key] !== undefined) present++;\n  return present === size;\n}\n","/**\n * Glob matching: `*`, `?`, and `\\` to escape either of them.\n *\n * What people mean when they reach for a pattern in a search box — `/api/*`,\n * `*.example.com` — and the reason it is not `$regex` with the sharp edges filed off: this\n * runs without a regular-expression engine, so it is available when patterns are turned\n * off for untrusted callers, and it cannot backtrack exponentially.\n *\n * No character classes. `[a-z]` is a literal `[a-z]`, because half a class syntax is worse\n * than none: somebody would write `[!abc]` expecting negation and get a match against those\n * four characters instead, with nothing to say so.\n *\n * **A pattern is taken apart once and becomes the narrowest matcher that fits it.** Nearly\n * every real glob is a prefix, a suffix, something in the middle, or a run of literals\n * separated by stars, and each of those is one or two native string calls per value. Only a\n * pattern with `?` in it walks character by character, and only that walk pays for splitting\n * the text into characters — which, measured against `startsWith`, was four times the cost of\n * the whole comparison.\n */\n\nexport type GlobMatcher = (text: string) => boolean;\n\n/**\n * What `*` and `?` become once the pattern is taken apart.\n *\n * Objects rather than strings, because a string sentinel is a string a *pattern* can also\n * contain: with a NUL-prefixed marker standing for `*`, the glob `a*\\u0000\\*` re-formed the\n * marker when the tokens were joined back together and was split in the wrong place — a\n * glob that silently matched everything.\n */\nconst ANY = { any: true } as const;\nconst ONE = { one: true } as const;\n\ntype Token = string | typeof ANY | typeof ONE;\n\nexport function compileGlob(pattern: string): GlobMatcher {\n  const tokens = tokenize(pattern);\n  const stars = tokens.includes(ANY);\n  const questions = tokens.includes(ONE);\n\n  if (!stars && !questions) {\n    const literal = tokens.join(\"\");\n    return (text) => text === literal;\n  }\n  if (!questions) {\n    // Literal runs separated by stars: each run is found with `indexOf`, left to right.\n    const segments: string[] = [\"\"];\n    for (const token of tokens) {\n      if (token === ANY) segments.push(\"\");\n      else segments[segments.length - 1] += token as string;\n    }\n    const open = segments[0] === \"\";\n    const close = segments[segments.length - 1] === \"\";\n    const parts = segments.filter((segment) => segment !== \"\");\n    if (parts.length === 0) return () => true;\n    if (open && close && parts.length === 1) {\n      const inside = parts[0] as string;\n      return (text) => text.includes(inside);\n    }\n    if (!open && close && parts.length === 1) {\n      const prefix = parts[0] as string;\n      return (text) => text.startsWith(prefix);\n    }\n    if (open && !close && parts.length === 1) {\n      const suffix = parts[0] as string;\n      return (text) => text.endsWith(suffix);\n    }\n    return (text) => scan(text, parts, open, close);\n  }\n  return (text) => walk([...text], tokens);\n}\n\n/**\n * The same glob as the body of a regular expression, for a target that speaks patterns\n * rather than running the matcher — a store this query is being pushed down to.\n *\n * It shares the tokenizer with the matcher on purpose: an escape read one way here and\n * another way there would mean a query that found different things depending on which half\n * of the system answered it.\n */\nexport function compileGlobPattern(pattern: string, quoteLiteral: (text: string) => string): string {\n  return tokenize(pattern)\n    .map((token) => (token === ANY ? \"[\\\\s\\\\S]*\" : token === ONE ? \"[\\\\s\\\\S]\" : quoteLiteral(token as string)))\n    .join(\"\");\n}\n\n/** Takes the pattern apart: literal characters, `ANY` for `*`, `ONE` for `?`. */\nfunction tokenize(pattern: string): Token[] {\n  const tokens: Token[] = [];\n  let escaped = false;\n  for (const character of pattern) {\n    if (escaped) {\n      tokens.push(character);\n      escaped = false;\n      continue;\n    }\n    if (character === \"\\\\\") {\n      escaped = true;\n      continue;\n    }\n    if (character === \"*\") {\n      // A run of stars means what one means, and collapsing it here keeps the matcher's\n      // backtracking to one mark per run.\n      if (tokens[tokens.length - 1] !== ANY) tokens.push(ANY);\n      continue;\n    }\n    tokens.push(character === \"?\" ? ONE : character);\n  }\n  // A trailing backslash is somebody mid-word, not an error: it stands for itself.\n  if (escaped) tokens.push(\"\\\\\");\n  return tokens;\n}\n\n/** Literal runs in order, anchored at each end unless a star opens or closes the pattern. */\nfunction scan(text: string, parts: readonly string[], open: boolean, close: boolean): boolean {\n  let at = 0;\n  const last = parts.length - 1;\n  for (let i = 0; i <= last; i++) {\n    const part = parts[i] as string;\n    if (i === 0 && !open) {\n      if (!text.startsWith(part)) return false;\n      at = part.length;\n      continue;\n    }\n    if (i === last && !close) {\n      // The final run has to be at the very end, and must not overlap what is matched.\n      return text.length - part.length >= at && text.endsWith(part);\n    }\n    const found = text.indexOf(part, at);\n    if (found === -1) return false;\n    at = found + part.length;\n  }\n  return true;\n}\n\n/** The two-pointer walk, for patterns holding `?`. Quadratic at worst, linear on anything typed. */\nfunction walk(characters: readonly string[], tokens: readonly Token[]): boolean {\n  let at = 0;\n  let token = 0;\n  let star = -1;\n  let mark = 0;\n  while (at < characters.length) {\n    const current = tokens[token];\n    if (current !== undefined && (current === ONE || current === characters[at])) {\n      at++;\n      token++;\n      continue;\n    }\n    if (current === ANY) {\n      star = token++;\n      mark = at;\n      continue;\n    }\n    if (star !== -1) {\n      token = star + 1;\n      at = ++mark;\n      continue;\n    }\n    return false;\n  }\n  while (tokens[token] === ANY) token++;\n  return token === tokens.length;\n}\n","import { JqlError } from \"./errors.js\";\nimport { alsoBig, equalsLiteral, type Equals } from \"./internal/equal.js\";\nimport { compileGlob } from \"./internal/glob.js\";\nimport { DURATION_UNITS } from \"./internal/duration.js\";\nimport { describe, isDateLiteral, isFieldReference, isOfType, isPlainObject, resolveDate, TYPE_NAMES, toTime } from \"./internal/values.js\";\nimport { didYouMean } from \"./internal/closest.js\";\nimport type { TypeName } from \"./types.js\";\n\n/**\n * What each field operator means, as a test on one value.\n *\n * Every builder here runs once, when a query is compiled, and returns the smallest\n * closure that answers its question: the operand is validated, normalised and, where it\n * helps, turned into a `Set` or a lower-cased copy before any document is seen. The\n * returned test only ever does the part that depends on the document.\n *\n * None of these knows about arrays or paths. Whether a test is also tried against each\n * element of an array, and how a field is reached, is `core.ts`'s business — so each\n * operator's meaning is written exactly once.\n */\nexport type Test = (value: unknown) => boolean;\n\nexport const NEVER: Test = () => false;\n\n/** Lower-cases the way the specification defines \"ignoring case\": Unicode default case mapping, no locale. */\nfunction lower(value: string): string {\n  return value.toLowerCase();\n}\n\n/**\n * Equality with one literal.\n *\n * `null` also matches a missing field, because \"has no value\" is what\n * people mean by it far more often than \"has the value null\". `$exists` is there for\n * the times the difference matters.\n */\nexport function equalsTest(literal: unknown, ignoreCase: boolean, at: string, now: number): Test {\n  checkLiteral(literal, at);\n  if (literal === null) return (value) => value === null || value === undefined;\n  return equalsLiteral(literal, now, ignoreCase);\n}\n\n/** Membership. A `Set` for the primitives, and a walk only for the object and array literals. */\nexport function inTest(list: unknown, ignoreCase: boolean, at: string, now: number): Test {\n  if (!Array.isArray(list)) throw new JqlError(`takes a list of values, not ${describe(list)}`, at);\n  if (list.length === 0) return NEVER;\n  const primitives = new Set<unknown>();\n  const complex: Equals[] = [];\n  // A whole number is the only way a query can name a big integer — JSON has no literal for\n  // one — but the two forms are kept in *separate* sets. Holding both in one made every\n  // lookup 1.17× the cost of a set of plain numbers, on every `$in` ever written, to serve a\n  // kind of value almost no document holds; this way the common path is the set it always\n  // was, and a big integer costs one comparison more, after that set has already said no.\n  let bigints: Set<bigint> | undefined;\n  let matchesMissing = false;\n  list.forEach((item, index) => {\n    checkLiteral(item, `${at}[${index}]`);\n    if (item === null) matchesMissing = true;\n    else if (typeof item === \"object\") complex.push(equalsLiteral(item, now, ignoreCase));\n    else {\n      primitives.add(ignoreCase && typeof item === \"string\" ? lower(item) : item);\n      const big = alsoBig(item);\n      if (big !== undefined) (bigints ??= new Set()).add(big);\n    }\n  });\n  const fold = ignoreCase;\n  const whole = bigints;\n  return (value) => {\n    if (value === undefined || value === null) return matchesMissing;\n    if (primitives.has(fold && typeof value === \"string\" ? lower(value) : value)) return true;\n    if (whole !== undefined && typeof value === \"bigint\" && whole.has(value)) return true;\n    for (let i = 0; i < complex.length; i++) if ((complex[i] as Equals)(value)) return true;\n    return false;\n  };\n}\n\ntype Ordering = \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\";\n\n/**\n * An ordering comparison.\n *\n * Only like with like: a number against numbers (and bigints), a string against strings\n * in code-unit order, a `$date` against anything that reads as a date. Nothing is\n * coerced, so `\"10\"` is not greater than `9` — a comparison that converted would give a\n * different answer depending on which side happened to be a string, and a query that\n * means different things on different documents is not one anybody can reason about.\n */\nexport function orderTest(operator: Ordering, bound: unknown, at: string, now: number): Test {\n  if (typeof bound === \"number\") {\n    if (Number.isNaN(bound)) throw new JqlError(\"NaN compares false with everything, so this would match nothing\", at);\n    switch (operator) {\n      case \"$gt\":\n        return (value) => (typeof value === \"number\" || typeof value === \"bigint\") && value > bound;\n      case \"$gte\":\n        return (value) => (typeof value === \"number\" || typeof value === \"bigint\") && value >= bound;\n      case \"$lt\":\n        return (value) => (typeof value === \"number\" || typeof value === \"bigint\") && value < bound;\n      case \"$lte\":\n        return (value) => (typeof value === \"number\" || typeof value === \"bigint\") && value <= bound;\n    }\n  }\n  if (typeof bound === \"string\") {\n    switch (operator) {\n      case \"$gt\":\n        return (value) => typeof value === \"string\" && value > bound;\n      case \"$gte\":\n        return (value) => typeof value === \"string\" && value >= bound;\n      case \"$lt\":\n        return (value) => typeof value === \"string\" && value < bound;\n      case \"$lte\":\n        return (value) => typeof value === \"string\" && value <= bound;\n    }\n  }\n  if (isDateLiteral(bound)) {\n    const time = resolveDate(bound.$date, now);\n    if (Number.isNaN(time)) throw new JqlError(`${JSON.stringify(bound.$date)} is not a date, so every comparison with it would be false`, at);\n    // A value in the document is only a date for the length of this comparison. A `Date`\n    // object is not a JSON value, so the engine does not assume one: strings and epoch\n    // numbers are read as dates here because the query said \"$date\".\n    switch (operator) {\n      case \"$gt\":\n        return (value) => value !== null && value !== undefined && toTime(value) > time;\n      case \"$gte\":\n        return (value) => value !== null && value !== undefined && toTime(value) >= time;\n      case \"$lt\":\n        return (value) => value !== null && value !== undefined && toTime(value) < time;\n      case \"$lte\":\n        return (value) => value !== null && value !== undefined && toTime(value) <= time;\n    }\n  }\n  throw new JqlError(`compares with a number, a string, a {\"$date\": …} or a {\"$field\": …}, not ${describe(bound)}`, at);\n}\n\ntype StringOperator = \"$contains\" | \"$startsWith\" | \"$endsWith\" | \"$word\" | \"$glob\";\n\n/**\n * The string operators, each taking one value or a list meaning \"any of these\".\n *\n * A list is there because \"the path starts with any of `/health`, `/metrics`\" is a single\n * thought, and spelling it as an `$or` of three conditions makes it three.\n */\nexport function stringTest(operator: StringOperator, operand: unknown, ignoreCase: boolean, at: string, maxGlobLength = Number.POSITIVE_INFINITY): Test {\n  const list = typeof operand === \"string\" ? [operand] : operand;\n  if (!Array.isArray(list)) throw new JqlError(`takes a string or a list of strings, not ${describe(operand)}`, at);\n  if (list.length === 0) return NEVER;\n  const wanted = list.map((item, index) => {\n    if (typeof item !== \"string\") throw new JqlError(`takes strings, not ${describe(item)}`, `${at}[${index}]`);\n    return ignoreCase ? lower(item) : item;\n  });\n  if (operator === \"$glob\") {\n    for (const pattern of wanted) {\n      if (pattern.length > maxGlobLength) throw new JqlError(`the glob is ${pattern.length} characters, past the limit of ${maxGlobLength}`, at);\n    }\n    // Taken apart once, into the narrowest matcher the pattern allows.\n    const globs = wanted.map(compileGlob);\n    if (globs.length === 1) {\n      const only = globs[0] as (text: string) => boolean;\n      return ignoreCase ? (value) => typeof value === \"string\" && only(lower(value)) : (value) => typeof value === \"string\" && only(value);\n    }\n    return (value) => {\n      if (typeof value !== \"string\") return false;\n      const actual = ignoreCase ? lower(value) : value;\n      for (let i = 0; i < globs.length; i++) if ((globs[i] as (text: string) => boolean)(actual)) return true;\n      return false;\n    };\n  }\n  const one = (actual: string, value: string): boolean => {\n    switch (operator) {\n      case \"$contains\":\n        return actual.includes(value);\n      case \"$startsWith\":\n        return actual.startsWith(value);\n      case \"$endsWith\":\n        return actual.endsWith(value);\n      case \"$word\":\n        return containsWord(actual, value);\n    }\n  };\n  if (wanted.length === 1) {\n    const only = wanted[0] as string;\n    // The common single-value `$contains` gets its own closure: no inner call, no loop.\n    if (operator === \"$contains\") return ignoreCase ? (value) => typeof value === \"string\" && lower(value).includes(only) : (value) => typeof value === \"string\" && value.includes(only);\n    return (value) => typeof value === \"string\" && one(ignoreCase ? lower(value) : value, only);\n  }\n  return (value) => {\n    if (typeof value !== \"string\") return false;\n    const actual = ignoreCase ? lower(value) : value;\n    for (let i = 0; i < wanted.length; i++) if (one(actual, wanted[i] as string)) return true;\n    return false;\n  };\n}\n\nconst ALPHANUMERIC = /[\\p{L}\\p{N}]/u;\n\n/**\n * The value as a whole component of the text: bounded on each side by the start or end of\n * the text, or by a character that is not a letter or digit.\n *\n * Ported from BotHandler's actor matching, where it replaced a substring test that let\n * `1.2.3.4` match `1.2.3.45` and `11.2.3.4` — so excluding one address excluded its\n * neighbours too. A side of the value that is itself a separator has chosen its own\n * boundary: `203.0.113.` finds the whole network.\n */\nexport function containsWord(actual: string, wanted: string): boolean {\n  if (wanted === \"\") return false;\n  const characters = [...wanted];\n  const startsAlphanumeric = ALPHANUMERIC.test(characters[0] as string);\n  const endsAlphanumeric = ALPHANUMERIC.test(characters[characters.length - 1] as string);\n  let from = 0;\n  for (;;) {\n    const at = actual.indexOf(wanted, from);\n    if (at === -1) return false;\n    const end = at + wanted.length;\n    const startsClean = at === 0 || !startsAlphanumeric || !ALPHANUMERIC.test(before(actual, at));\n    const endsClean = end >= actual.length || !endsAlphanumeric || !ALPHANUMERIC.test(after(actual, end));\n    if (startsClean && endsClean) return true;\n    from = at + 1;\n  }\n}\n\n/**\n * The character on either side of a boundary — a whole one.\n *\n * Read a code unit at a time, half of a letter outside the basic plane is a lone surrogate,\n * which is in no Unicode category at all, so `𝐀𝐁` looked like two words rather than one.\n */\nfunction before(text: string, at: number): string {\n  const code = text.charCodeAt(at - 1);\n  return code >= 0xdc00 && code <= 0xdfff && at >= 2 ? text.slice(at - 2, at) : (text[at - 1] as string);\n}\n\nfunction after(text: string, end: number): string {\n  const code = text.charCodeAt(end);\n  return code >= 0xd800 && code <= 0xdbff ? text.slice(end, end + 2) : (text[end] as string);\n}\n\n/** Flags `$options` may carry. `g` and `y` are refused: they make `RegExp.test` stateful, so a pattern would match on alternate calls. */\nconst OPTION_FLAGS = new Set([\"i\", \"m\", \"s\", \"u\"]);\n\nexport function parseOptions(options: unknown, at: string): string {\n  if (typeof options !== \"string\") throw new JqlError(`takes a string of flags such as \"i\", not ${describe(options)}`, at);\n  for (const flag of options) {\n    if (!OPTION_FLAGS.has(flag)) {\n      const why = flag === \"g\" || flag === \"y\" ? \": it makes a pattern stateful, so it would match on every other document\" : \"\";\n      throw new JqlError(`\"${flag}\" is not a flag this language takes (i, m, s, u)${why}`, at);\n    }\n  }\n  if (new Set(options).size !== options.length) throw new JqlError(`\"${options}\" repeats a flag`, at);\n  return options;\n}\n\nexport function regexTest(pattern: unknown, flags: string, limits: { allowRegex: boolean; maxPatternLength: number }, at: string): Test {\n  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);\n  if (typeof pattern !== \"string\") throw new JqlError(`takes the pattern as a string, not ${describe(pattern)}`, at);\n  if (pattern.length > limits.maxPatternLength) throw new JqlError(`the pattern is ${pattern.length} characters, past the limit of ${limits.maxPatternLength}`, at);\n  let expression: RegExp;\n  try {\n    expression = new RegExp(pattern, flags);\n  } catch (error) {\n    throw new JqlError(`the pattern does not compile: ${error instanceof Error ? error.message : String(error)}`, at);\n  }\n  return (value) => typeof value === \"string\" && expression.test(value);\n}\n\nexport function typeTest(operand: unknown, at: string): Test {\n  const list = typeof operand === \"string\" ? [operand] : operand;\n  if (!Array.isArray(list) || list.length === 0) throw new JqlError(`takes a type name or a non-empty list of them, not ${describe(operand)}`, at);\n  const types = list.map((name, index) => {\n    if (typeof name !== \"string\" || !(TYPE_NAMES as readonly string[]).includes(name)) {\n      throw new JqlError(`${describe(name)} is not a type name (${TYPE_NAMES.join(\", \")})${typeof name === \"string\" ? didYouMean(name, TYPE_NAMES) : \"\"}`, `${at}[${index}]`);\n    }\n    return name as TypeName;\n  });\n  if (types.length === 1) {\n    const only = types[0] as TypeName;\n    return (value) => isOfType(value, only);\n  }\n  return (value) => types.some((type) => isOfType(value, type));\n}\n\nexport function modTest(operand: unknown, at: string): Test {\n  if (!Array.isArray(operand) || operand.length !== 2 || typeof operand[0] !== \"number\" || typeof operand[1] !== \"number\") {\n    throw new JqlError(`takes [divisor, remainder], not ${describe(operand)}`, at);\n  }\n  const [divisor, remainder] = operand as [number, number];\n  if (divisor === 0 || !Number.isFinite(divisor)) throw new JqlError(\"a divisor of zero leaves no remainder to compare, so this would match nothing\", at);\n  // A big integer is a number everywhere else in the language — for ordering, and for\n  // `$type` (specification §5.3) — so it is one here. `%` refuses to mix a big integer with\n  // an ordinary one, so the divisor is converted once, when the query compiles; a divisor\n  // with a fraction cannot divide a big integer at all, and no value matches it.\n  const big = Number.isInteger(divisor) ? BigInt(divisor) : undefined;\n  return (value) => {\n    if (typeof value === \"number\") return value % divisor === remainder;\n    if (typeof value === \"bigint\") return big !== undefined && Number(value % big) === remainder;\n    return false;\n  };\n}\n\n/** `$all`: every literal is equal to the value or to one of its elements. An empty list matches nothing. */\nexport function allTest(list: unknown, ignoreCase: boolean, at: string, now: number): Test {\n  if (!Array.isArray(list)) throw new JqlError(`takes a list of values, not ${describe(list)}`, at);\n  if (list.length === 0) return NEVER;\n  const tests = list.map((item, index) => {\n    if (isPlainObject(item) && Object.keys(item).some((key) => key.startsWith(\"$\")) && !isDateLiteral(item)) {\n      throw new JqlError(\"takes values, not conditions; use $elemMatch inside $and for that\", `${at}[${index}]`);\n    }\n    return equalsTest(item, ignoreCase, `${at}[${index}]`, now);\n  });\n  return (value) => {\n    for (const test of tests) {\n      if (test(value)) continue;\n      if (!Array.isArray(value)) return false;\n      let found = false;\n      for (let i = 0; i < value.length; i++) {\n        if (test(value[i])) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) return false;\n    }\n    return true;\n  };\n}\n\n/**\n * The order of two values that both came out of a document, or `undefined` when they\n * cannot be compared.\n *\n * Only like with like, as everywhere else in the language: numbers with numbers, strings\n * with strings, dates with dates. Nothing is read as a date here, because neither side is\n * a query saying it is one — `{ \"$field\": … }` compares what the item holds.\n */\nexport function orderOf(a: unknown, b: unknown): number | undefined {\n  if ((typeof a === \"number\" || typeof a === \"bigint\") && (typeof b === \"number\" || typeof b === \"bigint\")) {\n    if (Number.isNaN(a) || Number.isNaN(b)) return undefined;\n    return a < b ? -1 : a > b ? 1 : 0;\n  }\n  if (typeof a === \"string\" && typeof b === \"string\") return a < b ? -1 : a > b ? 1 : 0;\n  if (a instanceof Date && b instanceof Date) {\n    const left = a.getTime();\n    const right = b.getTime();\n    return Number.isNaN(left) || Number.isNaN(right) ? undefined : left - right;\n  }\n  return undefined;\n}\n\n/**\n * Refuses a literal JSON cannot carry.\n *\n * A `RegExp`, a `Date`, a function or `undefined` in a query would work in the process\n * that wrote it and mean something else — or nothing — once the query was serialised.\n * The language is the JSON, so the engine holds to it even when handed an object that\n * could have been more.\n */\nexport function checkLiteral(value: unknown, at: string, depth = 0): void {\n  if (value === null || typeof value === \"string\" || typeof value === \"boolean\") return;\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) throw new JqlError(`${String(value)} is not a JSON number`, at);\n    return;\n  }\n  if (depth > 64) throw new JqlError(\"the literal nests deeper than 64 levels\", at);\n  if (Array.isArray(value)) {\n    value.forEach((item, index) => checkLiteral(item, `${at}[${index}]`, depth + 1));\n    return;\n  }\n  if (isPlainObject(value)) {\n    if (isFieldReference(value)) {\n      throw new JqlError(\n        `a {\"$field\": …} reference compares with another field, which $eq, $ne and the ordering operators do; it is not a value that can be held here`,\n        at,\n      );\n    }\n    if (isDateLiteral(value)) {\n      const date = value.$date;\n      if (Number.isNaN(resolveDate(date, 0))) {\n        const relative = isPlainObject(date) ? `; a relative date is {\"$ago\": \"1h\"} or {\"$ahead\": \"1h\"}, with a count and one of ${DURATION_UNITS.join(\", \")}` : \"\";\n        throw new JqlError(`${JSON.stringify(date)} is not a date${relative}`, `${at}.$date`);\n      }\n      return;\n    }\n    for (const key in value) checkLiteral(value[key], `${at}.${key}`, depth + 1);\n    return;\n  }\n  const hint = value instanceof RegExp ? '; write {\"$regex\": \"…\"} instead' : value instanceof Date ? '; write {\"$date\": \"…\"} instead' : \"\";\n  throw new JqlError(`${describe(value)} is not JSON, so a query holding it could not be stored or sent${hint}`, at);\n}\n","import { JqlError } from \"./errors.js\";\nimport { describe } from \"./internal/values.js\";\nimport type { PathValue } from \"./types.js\";\n\n/**\n * The names a query may use for one kind of document.\n *\n * Without one, a field name is a path and nothing more. With one, a collection gets the\n * names people actually type — `ip` for `actor`, `ua` for `request.headers.user-agent` —\n * and fields that are computed rather than stored, like BotHandler's `outcome`, which is\n * derived from the action and never kept anywhere.\n *\n * The same vocabulary serves the JSON engine and the text front end. That is deliberate:\n * two places that each kept their own list of field names would be two dialects within a\n * week, and a filter typed into a search box has to mean exactly what the JSON it becomes\n * means.\n */\n\n/**\n * How the text front end reads a value typed after `field:`. The JSON engine ignores it:\n * a JSON query says what it means with its operator.\n *\n * - `text` — contains the value, ignoring case. The default, and right for prose.\n * - `word` — contains it as a whole component (`1.2.3.4` does not find `1.2.3.45`). For identifiers.\n * - `exact` — equals it, ignoring case. For closed sets like a verdict or a method.\n * - `number` — compares: `>70`, `<=5`, `10..20`, `42`.\n * - `date` — compares instants the same way: `>2026-01-01`.\n * - `boolean` — `true`/`false`, `yes`/`no`, `1`/`0`.\n */\nexport type FieldKind = \"text\" | \"word\" | \"exact\" | \"number\" | \"date\" | \"boolean\";\n\nexport interface FieldDefinition<T = unknown> {\n  /** Where the value lives. Default: the field's own name. */\n  readonly path?: string | undefined;\n  /** Computes the value instead. Called once per document the field is tested against; it must not throw. */\n  readonly get?: ((document: T) => unknown) | undefined;\n  /** Other names that mean this field. */\n  readonly aliases?: readonly string[] | undefined;\n  /** Default `\"text\"`. */\n  readonly kind?: FieldKind | undefined;\n  /** The values worth offering as completions, when the set is closed. Leave out for a field that takes anything. */\n  readonly values?: readonly string[] | undefined;\n}\n\nexport interface VocabularyDefinition<T = unknown> {\n  readonly fields: Readonly<Record<string, FieldDefinition<T>>>;\n  /** The fields a bare search word looks in. Default: the whole document. */\n  readonly text?: readonly string[] | undefined;\n  /**\n   * Whether a name outside the vocabulary is refused. Default `false`, so any path still\n   * works alongside the named fields. Turn it on where the vocabulary is the whole\n   * contract — a public API whose documents may grow fields nobody promised to keep.\n   */\n  readonly strict?: boolean | undefined;\n}\n\n/** One field, with every name that reaches it already resolved. */\nexport interface VocabularyField<T = unknown> {\n  readonly name: string;\n  readonly kind: FieldKind;\n  readonly path: string;\n  readonly get: ((document: T) => unknown) | undefined;\n  readonly aliases: readonly string[];\n  readonly values: readonly string[] | undefined;\n}\n\n/**\n * A vocabulary ready to use.\n *\n * `Extra` is the type of the fields it names, so a typed query can use them: build one\n * with `defineVocabulary<Doc>()({ … })` and the computed names type-check.\n */\nexport interface Vocabulary<T = unknown, Extra extends object = {}> {\n  /** Every name, aliases included, lower-cased, to the field it means. */\n  readonly lookup: ReadonlyMap<string, VocabularyField<T>>;\n  /** The canonical fields, in the order they were defined. */\n  readonly fields: readonly VocabularyField<T>[];\n  /** Every name a query may use, aliases included, sorted. For completions. */\n  readonly names: readonly string[];\n  readonly text: readonly string[] | undefined;\n  readonly strict: boolean;\n  /** Carries the computed field types. Never present at run time. */\n  readonly __extra?: Extra | undefined;\n}\n\ntype ExtraOf<T, F> = {\n  [K in keyof F]: F[K] extends { get: (document: T) => infer R } ? R : F[K] extends { path: infer P extends string } ? PathValue<T, P> : K extends string ? PathValue<T, K> : unknown;\n};\n\n/** Names a query may never use for a field: they begin like an operator, or contain a path separator. */\nconst BAD_NAME = /^\\$|\\./;\n\n/**\n * Builds a vocabulary, refusing one that would quietly misbehave.\n *\n * Two names that collide, a text field that is not a field, a field with both a path and a\n * getter: each is a vocabulary that looks defined and means something other than what it\n * says, so each is an error here rather than a surprise at query time.\n *\n * Curried so the document type can be given while the field names are inferred:\n * `defineVocabulary<Request>()({ fields: { … } })`.\n */\nexport function defineVocabulary<T = unknown>(): <const D extends VocabularyDefinition<T>>(definition: D) => Vocabulary<T, ExtraOf<T, D[\"fields\"]>> {\n  return (definition) => build(definition) as Vocabulary<T, ExtraOf<T, (typeof definition)[\"fields\"]>>;\n}\n\n/**\n * Refuses anything that is not a vocabulary, where one was expected.\n *\n * Two mistakes land here, and both used to arrive as `Cannot read properties of undefined\n * (reading 'get')` from somewhere inside the engine. `defineVocabulary` is curried, so\n * `defineVocabulary({ fields: … })` — the empty parentheses forgotten — returns a *function*;\n * and a definition passed straight through is an object with no `lookup` on it. Neither is\n * caught by the types from JavaScript, and a `TypeError` is not a `JqlError`, so `validate`\n * re-threw it: the one call whose job is to answer 400 rather than 500 answered 500.\n */\nexport function checkVocabulary<T>(value: T, at = \"vocabulary\"): T {\n  if (value === undefined || (value !== null && typeof value === \"object\" && (value as { lookup?: unknown }).lookup instanceof Map)) return value;\n  throw new JqlError(\n    `is not a vocabulary, but ${describe(value)}: build one with defineVocabulary()({ fields: … }) — the empty parentheses first — and pass what that returns`,\n    at,\n  );\n}\n\nfunction build<T>(definition: VocabularyDefinition<T>): Vocabulary<T> {\n  const lookup = new Map<string, VocabularyField<T>>();\n  const fields: VocabularyField<T>[] = [];\n  const claim = (name: string, field: VocabularyField<T>): void => {\n    const key = name.toLowerCase();\n    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\");\n    const holder = lookup.get(key);\n    if (holder !== undefined) {\n      throw new JqlError(`\"${name}\" names both \"${holder.name}\" and \"${field.name}\", so a query using it could mean either`, \"vocabulary\");\n    }\n    lookup.set(key, field);\n  };\n\n  for (const [name, spec] of Object.entries(definition.fields)) {\n    if (spec.path !== undefined && spec.get !== undefined) {\n      throw new JqlError(`\"${name}\" has both a path and a getter; one of them would be ignored, so say which`, `vocabulary.${name}`);\n    }\n    if (spec.path === \"\") throw new JqlError(`\"${name}\" has an empty path, which reaches nothing`, `vocabulary.${name}`);\n    const field: VocabularyField<T> = {\n      name,\n      kind: spec.kind ?? \"text\",\n      path: spec.path ?? name,\n      get: spec.get,\n      aliases: spec.aliases ?? [],\n      values: spec.values,\n    };\n    fields.push(field);\n    claim(name, field);\n    for (const alias of field.aliases) claim(alias, field);\n  }\n\n  if (definition.text !== undefined) {\n    for (const name of definition.text) {\n      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\");\n    }\n  }\n\n  return {\n    lookup,\n    fields,\n    names: [...lookup.keys()].sort(),\n    text: definition.text,\n    strict: definition.strict ?? false,\n  };\n}\n","import { JqlError } from \"./errors.js\";\nimport { didYouMean } from \"./internal/closest.js\";\nimport { FANOUT, needsGuard, PLAIN, type Probe, probeFrom, probePath, type Read, type Reach, reachFrom, reachPath, readOwn, readSelf, splitPath } from \"./internal/path.js\";\nimport { describe, isDateLiteral, isFieldReference, isPlainObject } from \"./internal/values.js\";\nimport { DEFAULT_LIMITS, type Limits } from \"./limits.js\";\nimport { alsoBig, valuesEqual } from \"./internal/equal.js\";\nimport {\n  allTest,\n  checkLiteral,\n  orderOf,\n  equalsTest,\n  inTest,\n  modTest,\n  orderTest,\n  parseOptions,\n  regexTest,\n  stringTest,\n  type Test,\n  typeTest,\n} from \"./operators.js\";\nimport type { Matcher, QueryLike, UntypedQuery } from \"./types.js\";\nimport { checkVocabulary, type Vocabulary, type VocabularyField } from \"./vocabulary.js\";\n\n/**\n * The engine: a query document in, a predicate out.\n *\n * **Compile once, test many.** Everything that depends only on the query — validating it,\n * resolving field names, splitting paths, building sets for `$in`, lower-casing for `$options:\n * \"i\"`, compiling patterns — happens here, once. What comes back is a tree of small closures\n * that does only the part that depends on the document. Filtering a million items with one\n * query parses that query once, not a million times.\n *\n * **No code generation.** Emitting JavaScript source and calling `new Function` would be\n * faster still, and it would also be refused by every page with a Content-Security-Policy\n * worth having — including the dashboards in this project, whose build fails on a\n * `new Function`. Closures run everywhere.\n *\n * **Cheapest first.** The parts of an `$and` are reordered so an equality test runs before a\n * pattern and a pattern before a free-text walk, because the first part to fail decides the\n * answer and the rest never run. Every operator is a pure test, so the order changes the\n * cost and never the result.\n *\n * **No implicit cache.** A cache keyed on the query object would hand back a stale predicate\n * the moment somebody edited the object they had already queried with — a filter that looks\n * updated and is not. Compiling a small query costs about as much as testing a handful of\n * documents, so the helpers compile per call, and a hot loop calls `compile` once and keeps\n * the result.\n */\n\nexport interface CompileOptions<Extra extends object = {}> {\n  /** The field names, aliases and computed fields a query may use. Its fields become names a typed query may use. */\n  readonly vocabulary?: Vocabulary<never, Extra> | undefined;\n  /** How much of a query to accept. Default `DEFAULT_LIMITS`; use `UNTRUSTED_LIMITS` for queries from outside. */\n  readonly limits?: Partial<Limits> | undefined;\n  /**\n   * Where \"now\" comes from, for the relative dates in `{ \"$date\": { \"$ago\": \"1h\" } }`.\n   * Default the system clock, read **once**, when the query compiles.\n   *\n   * Read once because a window that moved while a scan was in progress would judge two\n   * items a second apart against different hours. It also means a long-lived compiled\n   * query keeps the instant it was compiled at: recompile to move the window, which costs\n   * well under a microsecond.\n   */\n  readonly now?: (() => number) | undefined;\n  /**\n   * Operators this project adds to the language, such as an address-in-network test that\n   * no amount of JSON could express.\n   *\n   * **A query using one is no longer portable JQL**, which is why their names must begin\n   * `$x`: somebody reading a stored filter can see at a glance that it needs more than a\n   * standard engine, and a future version of the language cannot collide with one.\n   */\n  readonly operators?: readonly OperatorDefinition[] | undefined;\n}\n\n/** An operator a project adds to the language. Its name must match `$x` followed by a capital: `$xCidr`. */\nexport interface OperatorDefinition {\n  readonly name: string;\n  /**\n   * Builds the test, once, when the query compiles. Throw `JqlError` for an operand this\n   * operator cannot use; the message reaches whoever wrote the query.\n   */\n  readonly compile: (operand: unknown, at: string) => (value: unknown) => boolean;\n  /** Roughly what it costs against the others, so an `$and` can run the cheap parts first. Default 4. */\n  readonly cost?: number | undefined;\n  /** Whether it is also tried against each element of an array value. Default true, like the built-in operators. */\n  readonly elementwise?: boolean | undefined;\n}\n\nconst EXTENSION_NAME = /^\\$x[A-Z][A-Za-z0-9]*$/;\n\n/** A predicate with its estimated cost, so an `$and` can run the cheap parts first. */\ninterface Compiled {\n  readonly test: (document: unknown) => boolean;\n  readonly cost: number;\n}\n\n/**\n * How a field is reached. `read` is present only when the path cannot fan out over an\n * array; `probe` when it can, but usually will not, so the straight read is worth trying\n * first.\n */\ninterface Field {\n  readonly read: Read | undefined;\n  readonly probe: Probe | undefined;\n  readonly reach: Reach;\n  /** A plain own-property name, for the fastest equality path. */\n  readonly key: string | undefined;\n  readonly cost: number;\n}\n\ninterface Context {\n  readonly vocabulary: Vocabulary<unknown, object> | undefined;\n  readonly limits: Limits;\n  readonly operators: ReadonlyMap<string, OperatorDefinition>;\n  /** The operators this query may use, or `undefined` when it may use all of them. */\n  readonly allowed: ReadonlySet<string> | undefined;\n  /** The instant every relative date in this query resolves against. */\n  readonly now: number;\n  nodes: number;\n}\n\nconst ALWAYS: Compiled = { test: () => true, cost: 0 };\nconst NOTHING: Compiled = { test: () => false, cost: 0 };\n\n/** The operators that combine queries. */\nexport const QUERY_OPERATORS: readonly string[] = [\"$and\", \"$or\", \"$nor\", \"$not\", \"$text\", \"$comment\"];\n\n/** The operators that test a field. At the top of a query they test the item itself. */\nexport const FIELD_OPERATORS: readonly string[] = [\n  \"$eq\",\n  \"$ne\",\n  \"$gt\",\n  \"$gte\",\n  \"$lt\",\n  \"$lte\",\n  \"$in\",\n  \"$nin\",\n  \"$exists\",\n  \"$type\",\n  \"$contains\",\n  \"$startsWith\",\n  \"$endsWith\",\n  \"$word\",\n  \"$glob\",\n  \"$regex\",\n  \"$options\",\n  \"$mod\",\n  \"$size\",\n  \"$length\",\n  \"$all\",\n  \"$elemMatch\",\n  \"$not\",\n];\n\nconst FIELD_OPERATOR_SET = new Set(FIELD_OPERATORS);\nconst EVERY_OPERATOR = [...new Set([...QUERY_OPERATORS, ...FIELD_OPERATORS])];\n\n/**\n * Operators whose meaning `$options: \"i\"` changes.\n *\n * Not in the barrel — this is the language's own list (specification §5.5), shared with\n * `explain`, which has to know which pieces of a condition the flag travels with.\n */\nexport const CASE_AWARE = new Set([\"$eq\", \"$ne\", \"$in\", \"$nin\", \"$all\", \"$contains\", \"$startsWith\", \"$endsWith\", \"$word\", \"$glob\", \"$regex\"]);\n\n/**\n * Compiles a query into a predicate.\n *\n * Throws `JqlError` for anything that is not a valid query, naming where in the query the\n * problem is. A function passed in is returned as it is, so every helper that takes a\n * query also takes a predicate somebody already has.\n */\nexport function compile<T = unknown, Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options: CompileOptions<Extra> = {}): Matcher<T> {\n  if (typeof query === \"function\") return query as Matcher<T>;\n  const limits = options.limits === undefined ? DEFAULT_LIMITS : { ...DEFAULT_LIMITS, ...options.limits };\n  const added = extensions(options.operators);\n  const context: Context = {\n    vocabulary: checkVocabulary(options.vocabulary) as Vocabulary<unknown, object> | undefined,\n    limits,\n    now: options.now === undefined ? Date.now() : options.now(),\n    operators: added,\n    allowed: allowlist(limits.allowOperators, added),\n    nodes: 0,\n  };\n  const { test } = compileQuery(query, context, \"\", 0);\n  // The shared constants are never handed out, so a caller that attaches something to\n  // the predicate it was given cannot reach every other query's.\n  if (test === ALWAYS.test) return () => true;\n  if (test === NOTHING.test) return () => false;\n  return test as Matcher<T>;\n}\n\n/** Whether one value matches a query. For a one-off; in a loop, `compile` once instead. */\nexport function matches<T, Extra extends object = {}>(value: T, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean {\n  return compile(query, options)(value);\n}\n\n/**\n * Checks a query, and hands back the predicate when it is a good one.\n *\n * What a service calls on a query it has just received, so it can answer 400 with the\n * sentence rather than 500 with a stack. The predicate comes with it because the caller\n * needs one next, and the two ways of getting it separately are both worse: compiling\n * again costs a second compile, and — the reason this returns it rather than only a\n * verdict — it is compiled from a second set of options, which is how a query gets\n * checked against the untrusted limits and then run without them.\n */\nexport function validate<T = unknown>(query: unknown, options?: CompileOptions<object>): { valid: true; test: Matcher<T> } | { valid: false; error: JqlError } {\n  try {\n    return { valid: true, test: compile<T>(query as QueryLike<T, object>, options) };\n  } catch (error) {\n    if (error instanceof JqlError) return { valid: false, error };\n    throw error;\n  }\n}\n\n/**\n * Marks a query from outside the type system — parsed JSON, a URL parameter — as one to be\n * checked when it is compiled rather than by the compiler. Returns the same object.\n */\nexport function untyped(query: unknown): UntypedQuery {\n  return query as UntypedQuery;\n}\n\n/**\n * How a field name is reached, by the same rules a query uses. For sorting and projection,\n * which must name fields exactly as the query beside them does. Not part of the public\n * surface.\n */\nexport function reachField(name: string, vocabulary: Vocabulary<unknown, object> | undefined, at: string): Reach {\n  return resolveField(name, { vocabulary, limits: DEFAULT_LIMITS, now: 0, operators: NO_EXTENSIONS, allowed: undefined, nodes: 0 }, at).reach;\n}\n\n/**\n * Operators that modify or annotate rather than ask anything, and so are never what an\n * allowlist is about.\n */\nconst ALWAYS_ALLOWED = new Set([\"$options\", \"$comment\"]);\n\n/** `$field` is not an operator key, but comparing two fields is a capability, so it is gateable by name. */\nconst GATEABLE = new Set([...FIELD_OPERATORS, ...QUERY_OPERATORS, \"$field\"]);\n\nfunction allowlist(names: readonly string[] | \"all\", added: ReadonlyMap<string, OperatorDefinition>): ReadonlySet<string> | undefined {\n  if (names === \"all\") return undefined;\n  if (!Array.isArray(names)) throw new JqlError(`is a list of operator names or \"all\", not ${describe(names)}`, \"limits.allowOperators\");\n  const out = new Set<string>();\n  for (const name of names) {\n    // A name nobody has is a list that does not say what its author meant: it would allow\n    // nothing and look like it allowed something.\n    if (typeof name !== \"string\" || (!GATEABLE.has(name) && !added.has(name))) {\n      throw new JqlError(`\"${String(name)}\" is not an operator, so allowing it allows nothing${typeof name === \"string\" ? didYouMean(name, [...GATEABLE]) : \"\"}`, \"limits.allowOperators\");\n    }\n    out.add(name);\n  }\n  return out;\n}\n\n/** Refuses an operator this query was not allowed to use. */\nfunction permit(key: string, context: Context, at: string): void {\n  const allowed = context.allowed;\n  if (allowed === undefined || ALWAYS_ALLOWED.has(key) || allowed.has(key)) return;\n  const listed = [...allowed];\n  const shown = listed.length > 8 ? `${listed.slice(0, 8).join(\", \")}, …` : listed.join(\", \");\n  throw new JqlError(`\"${key}\" is not an operator this query may use (${shown === \"\" ? \"none\" : shown})`, at);\n}\n\nconst NO_EXTENSIONS: ReadonlyMap<string, OperatorDefinition> = new Map();\n\nfunction extensions(given: readonly OperatorDefinition[] | undefined): ReadonlyMap<string, OperatorDefinition> {\n  if (given === undefined || given.length === 0) return NO_EXTENSIONS;\n  const out = new Map<string, OperatorDefinition>();\n  for (const definition of given) {\n    if (!EXTENSION_NAME.test(definition.name)) {\n      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\");\n    }\n    if (out.has(definition.name)) throw new JqlError(`\"${definition.name}\" is given twice, and the two could not both be it`, \"operators\");\n    if (typeof definition.compile !== \"function\") throw new JqlError(`\"${definition.name}\" has no compile function, so there is nothing for it to do`, \"operators\");\n    out.set(definition.name, definition);\n  }\n  return out;\n}\n\n/* ------------------------------------------------------------------------------------ */\n\nfunction count(context: Context, at: string): void {\n  context.nodes++;\n  if (context.nodes > context.limits.maxNodes) throw new JqlError(`the query holds more than ${context.limits.maxNodes} fields and operators`, at);\n}\n\nfunction join(at: string, key: string): string {\n  return at === \"\" ? key : `${at}.${key}`;\n}\n\nfunction compileQuery(query: unknown, context: Context, at: string, depth: number): Compiled {\n  if (depth > context.limits.maxDepth) throw new JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);\n  if (!isPlainObject(query)) throw new JqlError(`a query is an object, not ${describe(query)}`, at);\n  const parts: Compiled[] = [];\n  let self: Record<string, unknown> | undefined;\n  for (const key in query) {\n    const value = query[key];\n    const here = join(at, key);\n    if (value === undefined) {\n      throw new JqlError(\"the value is undefined; JSON has no undefined, and a condition on nothing would match everything\", here);\n    }\n    count(context, here);\n    if (!key.startsWith(\"$\")) {\n      parts.push(compileField(resolveField(key, context, here), value, context, here, depth));\n      continue;\n    }\n    permit(key, context, here);\n    switch (key) {\n      case \"$and\":\n        parts.push(allOf(queryList(value, context, here, depth)));\n        break;\n      case \"$or\":\n        parts.push(anyOf(queryList(value, context, here, depth)));\n        break;\n      case \"$nor\":\n        parts.push(negate(anyOf(queryList(value, context, here, depth))));\n        break;\n      case \"$not\":\n        parts.push(negate(compileQuery(value, context, here, depth + 1)));\n        break;\n      case \"$text\":\n        parts.push(compileText(value, context, here));\n        break;\n      case \"$comment\":\n        if (typeof value !== \"string\") throw new JqlError(`a comment is a string, not ${describe(value)}`, here);\n        break;\n      default:\n        if (!FIELD_OPERATOR_SET.has(key)) throw new JqlError(`\"${key}\" is not an operator${didYouMean(key, EVERY_OPERATOR)}`, here);\n        // A field operator at the top of a query is a condition on the item itself, which\n        // is what lets `[3, 8, 1].jqlFilter({ $gt: 2 })` work on an array of numbers.\n        self ??= {};\n        self[key] = value;\n    }\n  }\n  if (self !== undefined) parts.push(compileCondition(SELF, self, context, at, depth));\n  return allOf(parts);\n}\n\nfunction queryList(value: unknown, context: Context, at: string, depth: number): Compiled[] {\n  if (!Array.isArray(value)) throw new JqlError(`takes a list of queries, not ${describe(value)}`, at);\n  return value.map((item, index) => compileQuery(item, context, `${at}[${index}]`, depth + 1));\n}\n\n/* ------------------------------------------------------------------------------------ */\n/* Fields                                                                               */\n/* ------------------------------------------------------------------------------------ */\n\nconst SELF: Field = { read: readSelf, probe: undefined, reach: (document, test) => test(document), key: undefined, cost: 0 };\n\n/**\n * What a field name reaches: a vocabulary field, a vocabulary field followed by a path into\n * it, or a plain path.\n */\nfunction resolveField(name: string, context: Context, at: string): Field {\n  const vocabulary = context.vocabulary;\n  if (vocabulary !== undefined) {\n    const direct = vocabulary.lookup.get(name.toLowerCase());\n    if (direct !== undefined) return fieldOf(direct, [], at);\n    const dot = name.indexOf(\".\");\n    if (dot > 0) {\n      const head = vocabulary.lookup.get(name.slice(0, dot).toLowerCase());\n      if (head !== undefined) {\n        const rest = splitPath(name.slice(dot + 1));\n        if (typeof rest === \"string\") throw new JqlError(rest, at);\n        return fieldOf(head, rest, at);\n      }\n    }\n    if (vocabulary.strict) throw new JqlError(`\"${name}\" is not a field here${didYouMean(name, vocabulary.names)}`, at);\n  }\n  const keys = splitPath(name);\n  if (typeof keys === \"string\") throw new JqlError(keys, at);\n  return pathField(keys);\n}\n\nfunction fieldOf(field: VocabularyField, rest: readonly string[], at: string): Field {\n  if (field.get !== undefined) {\n    const get = field.get as Read;\n    if (rest.length === 0) return { read: get, probe: undefined, reach: (document, test) => test(get(document)), key: undefined, cost: 3 };\n    return { read: undefined, probe: probeFrom(get, rest), reach: reachFrom(get, rest), key: undefined, cost: 3 + rest.length };\n  }\n  const keys = splitPath(field.path);\n  if (typeof keys === \"string\") throw new JqlError(keys, at);\n  return pathField([...keys, ...rest]);\n}\n\nfunction pathField(keys: readonly string[]): Field {\n  // Even one segment can reach several values: an item that is itself an array is seen\n  // through, exactly as an array met further down a path is. So a single key is probed like\n  // any other path — quickly, and with the fan-out behind it when the probe meets an array.\n  if (keys.length === 1) {\n    const key = keys[0] as string;\n    return { read: undefined, probe: probePath(keys), reach: reachPath(keys), key, cost: 0 };\n  }\n  return { read: undefined, probe: probePath(keys), reach: reachPath(keys), key: undefined, cost: keys.length };\n}\n\n/** `{ field: literal }`, `{ field: { $field: … } }`, or `{ field: { $op: … } }`. */\nfunction compileField(field: Field, value: unknown, context: Context, at: string, depth: number): Compiled {\n  // A reference is a value to compare with, like a date literal, rather than a condition.\n  if (isFieldReference(value)) {\n    permit(\"$field\", context, at);\n    permit(\"$eq\", context, at);\n    return compareFields(field, \"$eq\", value.$field, false, context, at);\n  }\n  if (isPlainObject(value) && !isDateLiteral(value)) {\n    let operators = 0;\n    let names = 0;\n    // A value written plainly still asks for equality, so it is gated as `$eq` is.\n    for (const key in value) {\n      if (key.startsWith(\"$\")) operators++;\n      else names++;\n    }\n    if (operators > 0 && names > 0) {\n      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);\n    }\n    if (operators > 0) return compileCondition(field, value, context, at, depth + 1);\n  }\n  permit(\"$eq\", context, at);\n  return equality(field, value, false, at, context.now);\n}\n\n/* ------------------------------------------------------------------------------------ */\n/* Conditions                                                                           */\n/* ------------------------------------------------------------------------------------ */\n\n/** One operator of a condition, as a test on the field's value. */\ninterface ValueTest {\n  readonly test: Test;\n  readonly cost: number;\n  readonly negated: boolean;\n  /** The test before it was made to look into arrays, when it was; lets a lone operator inline that loop. */\n  readonly any: Test | undefined;\n}\n\n/**\n * Every operator of one condition object.\n *\n * On a field with a single value — a plain property, or a path that meets no array — the\n * operators are fused into one test over one read: `{ age: { $gte: 30, $lt: 50 } }` reads\n * `age` once and compares twice. That fusion is only sound when the field has one value.\n * On a path that fans out over an array each operator has to be tested separately, because\n * \"some element is at least 30 and some element is under 50\" is what the language says\n * there, and one element satisfying both is `$elemMatch`.\n */\nfunction compileCondition(field: Field, condition: Record<string, unknown>, context: Context, at: string, depth: number): Compiled {\n  const { values, whole } = conditionParts(field, condition, context, at, depth);\n  return combine(field, values, whole);\n}\n\n/** The value tests and the document-level tests of one condition, as a single predicate. */\nfunction combine(field: Field, values: readonly ValueTest[], whole: readonly Compiled[]): Compiled {\n  const parts = [...whole];\n  if (values.length > 0) {\n    const cost = values.reduce((sum, value) => sum + value.cost, 0);\n    if (field.read !== undefined) {\n      const only = values.length === 1 ? (values[0] as ValueTest) : undefined;\n      parts.push(only !== undefined && only.any !== undefined ? holdsAny(field, only.any, only.negated, cost) : holds(field, allOfValues(values), cost));\n    } else {\n      const separate = allOf(values.map((value) => (value.negated ? negate(holds(field, value.test, value.cost)) : holds(field, value.test, value.cost))));\n      const probe = field.probe;\n      if (probe === undefined) parts.push(separate);\n      else {\n        // One value, fused; an array on the way, each operator on its own.\n        const fused = allOfValues(values);\n        const fallback = separate.test;\n        parts.push({ test: (document) => {\n          const value = probe(document);\n          return value === FANOUT ? fallback(document) : fused(value);\n        }, cost: separate.cost });\n      }\n    }\n  }\n  return allOf(parts);\n}\n\nfunction conditionParts(field: Field, condition: Record<string, unknown>, context: Context, at: string, depth: number): { values: ValueTest[]; whole: Compiled[] } {\n  if (depth > context.limits.maxDepth) throw new JqlError(`the query nests deeper than ${context.limits.maxDepth} levels`, at);\n  let flags = \"\";\n  if (condition.$options !== undefined) {\n    flags = parseOptions(condition.$options, join(at, \"$options\"));\n    const usesCase = Object.keys(condition).some((key) => CASE_AWARE.has(key));\n    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\"));\n    if (/[msu]/.test(flags) && condition.$regex === undefined) throw new JqlError(`the flags \"${flags.replace(\"i\", \"\")}\" only mean something to $regex, and there is none here`, join(at, \"$options\"));\n  }\n  const ignoreCase = flags.includes(\"i\");\n  const values: ValueTest[] = [];\n  const whole: Compiled[] = [];\n  const add = (test: Test, cost: number, negated = false): void => {\n    values.push({ test, cost, negated, any: undefined });\n  };\n  const addAny = (test: Test, cost: number, negated = false): void => {\n    values.push({ test: elementwise(test), cost, negated, any: test });\n  };\n  for (const key in condition) {\n    const operand = condition[key];\n    const here = join(at, key);\n    if (operand === undefined) throw new JqlError(\"the value is undefined; JSON has no undefined, and a condition on nothing would match everything\", here);\n    count(context, here);\n    permit(key, context, here);\n    switch (key) {\n      case \"$options\":\n        break;\n      case \"$eq\":\n      case \"$ne\": {\n        const negated = key === \"$ne\";\n        const reference = referencePath(operand, here);\n        if (reference !== undefined) {\n          permit(\"$field\", context, here);\n          whole.push(compareFields(field, \"$eq\", reference, negated, context, here));\n          break;\n        }\n        add(equalsValue(operand, ignoreCase, here, context.now), operand !== null && typeof operand === \"object\" ? 3 : 0, negated);\n        break;\n      }\n      case \"$gt\":\n      case \"$gte\":\n      case \"$lt\":\n      case \"$lte\": {\n        const reference = referencePath(operand, here);\n        if (reference !== undefined) {\n          permit(\"$field\", context, here);\n          whole.push(compareFields(field, key, reference, false, context, here));\n          break;\n        }\n        addAny(orderTest(key, operand, here, context.now), 1);\n      }\n        break;\n      case \"$in\":\n        addAny(inTest(operand, ignoreCase, here, context.now), 1);\n        break;\n      case \"$nin\":\n        addAny(inTest(operand, ignoreCase, here, context.now), 1, true);\n        break;\n      case \"$exists\":\n        if (typeof operand !== \"boolean\") throw new JqlError(`takes true or false, not ${describe(operand)}`, here);\n        add(isPresent, 0, !operand);\n        break;\n      case \"$type\":\n        addAny(typeTest(operand, here), 1);\n        break;\n      case \"$contains\":\n      case \"$startsWith\":\n      case \"$endsWith\":\n      case \"$word\":\n      case \"$glob\":\n        addAny(stringTest(key, operand, ignoreCase, here, context.limits.maxGlobLength), key === \"$word\" || key === \"$glob\" ? 4 : 2);\n        break;\n      case \"$regex\":\n        addAny(regexTest(operand, flags, context.limits, here), 5);\n        break;\n      case \"$mod\":\n        addAny(modTest(operand, here), 1);\n        break;\n      case \"$size\":\n        add(sizeTest(operand, context, here, depth, \"array\"), 1);\n        break;\n      case \"$length\":\n        add(sizeTest(operand, context, here, depth, \"anything with a length\"), 1);\n        break;\n      case \"$all\":\n        add(allTest(operand, ignoreCase, here, context.now), 4);\n        break;\n      case \"$elemMatch\": {\n        if (!isPlainObject(operand)) throw new JqlError(`takes a query for one element, not ${describe(operand)}`, here);\n        const element = compileQuery(operand, context, here, depth + 1);\n        const test = element.test;\n        add((value) => {\n          if (!Array.isArray(value)) return false;\n          for (let i = 0; i < value.length; i++) if (test(value[i])) return true;\n          return false;\n        }, 4 + element.cost);\n        break;\n      }\n      case \"$not\": {\n        if (!isPlainObject(operand) || isDateLiteral(operand) || !Object.keys(operand).every((name) => name.startsWith(\"$\"))) {\n          throw new JqlError(`takes a condition such as { \"$gt\": 5 }, not ${describe(operand)}; to negate a value, use $ne`, here);\n        }\n        const inner = conditionParts(field, operand, context, here, depth + 1);\n        // Only when every part of it is a test on the value can the negation be one too.\n        // A `$not` holding something that needs the whole document — a `{ \"$field\": … }`\n        // reference — used to have that part quietly left out of the negation, so\n        // `{ a: { $not: { $exists: false, $eq: { $field: \"b\" } } } }` was answered without\n        // ever looking at `b`: a query that reads as restrictive and was not.\n        if (field.read !== undefined && inner.whole.length === 0) {\n          add(allOfValues(inner.values), inner.values.reduce((sum, value) => sum + value.cost, 0), true);\n          break;\n        }\n        whole.push(negate(combine(field, inner.values, inner.whole)));\n        break;\n      }\n      default: {\n        const extension = context.operators.get(key);\n        if (extension !== undefined) {\n          const test = extension.compile(operand, here);\n          if (typeof test !== \"function\") throw new JqlError(`\"${key}\" did not build a test, so there is nothing to run`, here);\n          const cost = extension.cost ?? 4;\n          if (extension.elementwise === false) add(test, cost);\n          else addAny(test, cost);\n          break;\n        }\n        const reason = QUERY_OPERATORS.includes(key)\n          ? `\"${key}\" combines whole queries, so it belongs beside field names rather than inside a field's condition`\n          : EXTENSION_NAME.test(key)\n            ? `\"${key}\" is an added operator, and this query was compiled without it; pass it in \\`operators\\``\n            : `\"${key}\" is not an operator${didYouMean(key, [...FIELD_OPERATORS, ...context.operators.keys()])}`;\n        throw new JqlError(reason, here);\n      }\n    }\n  }\n  return { values, whole };\n}\n\n/** Every value test, cheapest first, with negation applied. */\nfunction allOfValues(values: readonly ValueTest[]): Test {\n  const tests = [...values].sort((a, b) => a.cost - b.cost).map(({ test, negated }): Test => (negated ? (value) => !test(value) : test));\n  if (tests.length === 0) return () => true;\n  if (tests.length === 1) return tests[0] as Test;\n  if (tests.length === 2) {\n    const [a, b] = tests as [Test, Test];\n    return (value) => a(value) && b(value);\n  }\n  return (value) => {\n    for (let i = 0; i < tests.length; i++) if (!(tests[i] as Test)(value)) return false;\n    return true;\n  };\n}\n\nconst isPresent: Test = (value) => value !== undefined;\n\n/**\n * A test that also holds when it holds for any element of an array value.\n *\n * The whole array is tried first, so `{ tags: [\"a\", \"b\"] }` can match the array exactly\n * and `{ tags: \"a\" }` can match one of its elements.\n */\nfunction elementwise(test: Test): Test {\n  return (value) => {\n    if (test(value)) return true;\n    if (!Array.isArray(value)) return false;\n    for (let i = 0; i < value.length; i++) if (test(value[i])) return true;\n    return false;\n  };\n}\n\n/**\n * Applies a value test to whatever the field reaches.\n *\n * A plain property is read inline rather than through its accessor: one call per document\n * instead of two, which on a filter over a large array is most of the engine's own cost.\n */\nfunction holds(field: Field, test: Test, cost: number): Compiled {\n  const key = field.key;\n  if (key !== undefined) {\n    const reach = field.reach;\n    const plain = !needsGuard(key);\n    return {\n      test: (document) => {\n        if (document === null || typeof document !== \"object\") return test(undefined);\n        if (Array.isArray(document)) return reach(document, test);\n        return test(plain && (document as { __proto__?: unknown }).__proto__ === PLAIN ? (document as Record<string, unknown>)[key] : readOwn(document, key));\n      },\n      cost: field.cost + cost,\n    };\n  }\n  const read = field.read;\n  // A condition on the item itself — what `$size` and `$length` compile their inner\n  // condition against — is already a test on the value: wrapping it would call the identity\n  // once per document to arrive back where it started.\n  if (read === readSelf) return { test, cost: field.cost + cost };\n  if (read !== undefined) return { test: (document) => test(read(document)), cost: field.cost + cost };\n  const reach = field.reach;\n  const probe = field.probe;\n  if (probe !== undefined) {\n    return {\n      test: (document) => {\n        const value = probe(document);\n        return value === FANOUT ? reach(document, test) : test(value);\n      },\n      cost: field.cost + cost,\n    };\n  }\n  return { test: (document) => reach(document, test), cost: field.cost + cost };\n}\n\n/**\n * A lone operator on a single-valued field, with the look into arrays written inline, so a\n * document costs one call to the operator rather than one to a wrapper and one to it.\n */\nfunction holdsAny(field: Field, test: Test, negated: boolean, cost: number): Compiled {\n  const key = field.key;\n  if (key === undefined) {\n    const read = field.read as Read;\n    const single = (value: unknown): boolean => {\n      if (test(value)) return true;\n      if (!Array.isArray(value)) return false;\n      for (let i = 0; i < value.length; i++) if (test(value[i])) return true;\n      return false;\n    };\n    return { test: negated ? (document) => !single(read(document)) : (document) => single(read(document)), cost: field.cost + cost };\n  }\n  const reach = field.reach;\n  const plain = !needsGuard(key);\n  const any = (value: unknown): boolean => {\n    if (test(value)) return true;\n    if (!Array.isArray(value)) return false;\n    for (let i = 0; i < value.length; i++) if (test(value[i])) return true;\n    return false;\n  };\n  const hit = (document: unknown): boolean => {\n    if (document === null || typeof document !== \"object\") return test(undefined);\n    if (Array.isArray(document)) return reach(document, any);\n    return any(plain && (document as { __proto__?: unknown }).__proto__ === PLAIN ? (document as Record<string, unknown>)[key] : readOwn(document, key));\n  };\n  return { test: negated ? (document) => !hit(document) : hit, cost: field.cost + cost };\n}\n\n/** Equality with one literal, looking into arrays. A primitive gets a closure with no inner call. */\nfunction equalsValue(literal: unknown, ignoreCase: boolean, at: string, now: number): Test {\n  if (!ignoreCase && (typeof literal === \"string\" || typeof literal === \"number\" || typeof literal === \"boolean\")) {\n    checkLiteral(literal, at);\n    const wanted = literal;\n    // A whole number is also asking about the big integer of the same value (§5.1); every\n    // other literal is a single comparison, exactly as before.\n    const big = alsoBig(literal);\n    if (big !== undefined) return (value) => value === wanted || value === big || (Array.isArray(value) && (value.includes(wanted) || value.includes(big)));\n    return (value) => value === wanted || (Array.isArray(value) && value.includes(wanted));\n  }\n  return elementwise(equalsTest(literal, ignoreCase, at, now));\n}\n\n/**\n * Equality, with the case that dominates real use written out in full.\n *\n * `{ id: 2 }` on a plain property compiles to one closure with the read, the comparison and\n * the array fallback inline: no accessor call, no test call. It is the one query that runs\n * as fast as the loop somebody would have written by hand, because it is that loop.\n */\nfunction equality(field: Field, literal: unknown, ignoreCase: boolean, at: string, now: number): Compiled {\n  const key = field.key;\n  if (key !== undefined && !ignoreCase && (typeof literal === \"string\" || typeof literal === \"number\" || typeof literal === \"boolean\")) {\n    checkLiteral(literal, at);\n    const wanted = literal;\n    const reach = field.reach;\n    const plain = !needsGuard(key);\n    const test = equalsValue(literal, false, at, now);\n    const big = alsoBig(literal);\n    // Two closures rather than one with a branch in it: a whole number also stands for the\n    // big integer of the same value, and every other literal must not pay for that — nor\n    // compare against an `undefined` standing in for \"there is no such big integer\", which\n    // is what a missing field reads as. The read is written out in both, rather than shared\n    // through a helper: `{ \"id\": 2 }` takes this path, and a call per document is most of\n    // what this closure costs.\n    if (big !== undefined) {\n      return {\n        test: (document) => {\n          if (document === null || typeof document !== \"object\") return false;\n          if (Array.isArray(document)) return reach(document, test);\n          const value = plain && (document as { __proto__?: unknown }).__proto__ === PLAIN ? (document as Record<string, unknown>)[key] : readOwn(document, key);\n          return value === wanted || value === big || (Array.isArray(value) && (value.includes(wanted) || value.includes(big)));\n        },\n        cost: 0,\n      };\n    }\n    return {\n      test: (document) => {\n        if (document === null || typeof document !== \"object\") return false;\n        // An item that is itself an array is seen through, so the walk answers for it.\n        if (Array.isArray(document)) return reach(document, test);\n        const value = plain && (document as { __proto__?: unknown }).__proto__ === PLAIN ? (document as Record<string, unknown>)[key] : readOwn(document, key);\n        return value === wanted || (Array.isArray(value) && value.includes(wanted));\n      },\n      cost: 0,\n    };\n  }\n  const probe = field.probe;\n  if (probe !== undefined && !ignoreCase && (typeof literal === \"string\" || typeof literal === \"number\" || typeof literal === \"boolean\")) {\n    checkLiteral(literal, at);\n    const wanted = literal;\n    const test = equalsValue(literal, false, at, now);\n    const reach = field.reach;\n    const big = alsoBig(literal);\n    if (big !== undefined) {\n      return {\n        test: (document) => {\n          const value = probe(document);\n          if (value === wanted || value === big) return true;\n          if (value === FANOUT) return reach(document, test);\n          return Array.isArray(value) && (value.includes(wanted) || value.includes(big));\n        },\n        cost: field.cost,\n      };\n    }\n    return {\n      test: (document) => {\n        const value = probe(document);\n        if (value === wanted) return true;\n        if (value === FANOUT) return reach(document, test);\n        return Array.isArray(value) && value.includes(wanted);\n      },\n      cost: field.cost,\n    };\n  }\n  return holds(field, equalsValue(literal, ignoreCase, at, now), literal !== null && typeof literal === \"object\" ? 3 : 0);\n}\n\n/**\n * `$size` and `$length`, which differ only in what they will measure.\n *\n * Neither is tried against the elements of an array, unlike the string operators:\n * `{ tags: { $length: 1 } }` would otherwise mean both \"one tag\" and \"a tag one character\n * long\", and nothing in the query would say which. A string's length is counted in UTF-16\n * code units — what a cap on an incoming value is counted in, and what JSON's own escape\n * syntax is defined in.\n */\nfunction sizeTest(operand: unknown, context: Context, at: string, depth: number, measures: \"array\" | \"anything with a length\"): Test {\n  const strings = measures !== \"array\";\n  let length: (size: number) => boolean;\n  if (typeof operand === \"number\") {\n    if (!Number.isInteger(operand) || operand < 0) throw new JqlError(`a length is a whole number, not ${operand}`, at);\n    length = (size) => size === operand;\n  } else if (isPlainObject(operand)) {\n    length = compileCondition(SELF, operand, context, at, depth + 1).test;\n  } else throw new JqlError(`takes a number or a condition on one, not ${describe(operand)}`, at);\n  if (strings) return (value) => (typeof value === \"string\" || Array.isArray(value)) && length(value.length);\n  return (value) => Array.isArray(value) && length(value.length);\n}\n\n/**\n * A comparison between two fields of the same item.\n *\n * Both sides are reached the way any path is, so either can fan out over an array, and the\n * comparison holds when **some** pair of values satisfies it — the same \"any of them\" the\n * rest of the language uses. `$ne` is the negation of that: no pair does.\n *\n * Nothing here reads a value as a date. A `{ \"$date\": … }` in a query is the query saying\n * what it means; a reference says only where to look, and the item's own values decide.\n */\nfunction compareFields(field: Field, operator: \"$eq\" | \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\", path: string, negated: boolean, context: Context, at: string): Compiled {\n  const other = resolveField(path, context, at);\n  // Settled once: the operator is known here, and asking it again per pair of values was\n  // most of what a reference cost.\n  const compare = comparer(operator);\n  const leftRead = field.read;\n  const rightRead = other.read;\n  let holdsPair: (document: unknown) => boolean;\n  if (leftRead !== undefined && rightRead !== undefined) {\n    // Both sides are single-valued — a plain property on each — which is what a reference\n    // nearly always is. No walk, no callback: two reads and a comparison.\n    holdsPair = (document) => eachOf(leftRead(document), (one) => eachOf(rightRead(document), (two) => compare(one, two)));\n  } else {\n    const left = field.reach;\n    const right = other.reach;\n    holdsPair = (document) => left(document, (one) => eachOf(one, (a) => right(document, (two) => eachOf(two, (b) => compare(a, b)))));\n  }\n  return { test: negated ? (document) => !holdsPair(document) : holdsPair, cost: field.cost + other.cost + 4 };\n}\n\n/** One comparison, chosen when the query compiles rather than per pair of values. */\nfunction comparer(operator: \"$eq\" | \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\"): (a: unknown, b: unknown) => boolean {\n  if (operator === \"$eq\") return (a, b) => a !== undefined && b !== undefined && valuesEqual(a, b);\n  return (a, b) => {\n    if (a === undefined || b === undefined) return false;\n    const order = orderOf(a, b);\n    if (order === undefined) return false;\n    switch (operator) {\n      case \"$gt\":\n        return order > 0;\n      case \"$gte\":\n        return order >= 0;\n      case \"$lt\":\n        return order < 0;\n      default:\n        return order <= 0;\n    }\n  };\n}\n\n/**\n * The path in a `{ \"$field\": … }` reference, or `undefined` when the operand is not one.\n *\n * A malformed reference is refused here rather than falling through to \"compares with a\n * number, a string or a date, not an object\", which is a true sentence that tells somebody\n * who wrote `{ \"$field\": 5 }` nothing about what they got wrong.\n */\nfunction referencePath(operand: unknown, at: string): string | undefined {\n  if (!isPlainObject(operand) || !(\"$field\" in operand)) return undefined;\n  if (typeof operand.$field !== \"string\") throw new JqlError(`a {\"$field\": …} reference takes the path as a string, not ${describe(operand.$field)}`, at);\n  const beside = Object.keys(operand).filter((key) => key !== \"$field\");\n  if (beside.length > 0) throw new JqlError(`a {\"$field\": …} reference holds nothing but the path, and \"${beside[0]}\" is beside it`, at);\n  return operand.$field;\n}\n\n/** A value, and then each of its elements when it is an array. */\nfunction eachOf(value: unknown, test: (item: unknown) => boolean): boolean {\n  if (test(value)) return true;\n  if (!Array.isArray(value)) return false;\n  for (let i = 0; i < value.length; i++) if (test(value[i])) return true;\n  return false;\n}\n\n/* ------------------------------------------------------------------------------------ */\n/* Free text                                                                            */\n/* ------------------------------------------------------------------------------------ */\n\nfunction compileText(value: unknown, context: Context, at: string): Compiled {\n  let search: unknown;\n  let fields: unknown;\n  let caseSensitive: unknown = false;\n  if (typeof value === \"string\") search = value;\n  else if (isPlainObject(value)) {\n    for (const key in value) {\n      if (key !== \"$search\" && key !== \"$fields\" && key !== \"$caseSensitive\") {\n        throw new JqlError(`\"${key}\" is not part of a text search ($search, $fields, $caseSensitive)${didYouMean(key, [\"$search\", \"$fields\", \"$caseSensitive\"])}`, join(at, key));\n      }\n    }\n    search = value.$search;\n    fields = value.$fields;\n    // Read as written, not defaulted: `?? false` turned an explicit `null` into \"no\", and\n    // `?? vocabulary.text` turned `$fields: null` into a search of the whole item — a\n    // narrower question silently becoming a wider one.\n    caseSensitive = \"$caseSensitive\" in value ? value.$caseSensitive : false;\n  } else throw new JqlError(`takes a phrase or { \"$search\": … }, not ${describe(value)}`, at);\n  if (typeof search !== \"string\") throw new JqlError(`the phrase is a string, not ${describe(search)}`, join(at, \"$search\"));\n  if (typeof caseSensitive !== \"boolean\") throw new JqlError(`takes true or false, not ${describe(caseSensitive)}`, join(at, \"$caseSensitive\"));\n\n  // The fields are resolved before the phrase is read, because whether a query is a good one\n  // cannot depend on how much of it somebody has typed. An empty phrase returned \"matches\n  // everything\" first, so `{ \"$search\": \"\", \"$fields\": 42 }` compiled, and a dashboard that\n  // validated its saved filter while the box was empty was told it was fine — until the\n  // first letter, when the same filter was refused.\n  const names = fields === undefined ? context.vocabulary?.text : fields;\n  const reaches = names === undefined ? undefined : textFields(names, context, at);\n\n  const needle = caseSensitive ? search : search.toLowerCase();\n  // An empty search box is a question nobody has asked yet, and the answer to that is\n  // everything — the same as an empty query.\n  if (needle === \"\") return ALWAYS;\n  const found: (text: string) => boolean = caseSensitive ? (text) => text.includes(needle) : (text) => text.toLowerCase().includes(needle);\n  // Numbers are searched only when the phrase could be part of one. Formatting every\n  // number in every document to look for a word with no digits in it is pure cost.\n  const numeric = /\\d/.test(needle);\n  const maxDepth = context.limits.maxTextDepth;\n  const inValue: Test = (item) => containsText(item, found, numeric, maxDepth);\n\n  if (reaches === undefined) return { test: inValue, cost: 20 };\n  return {\n    test: (document) => {\n      for (let i = 0; i < reaches.length; i++) if ((reaches[i] as Reach)(document, inValue)) return true;\n      return false;\n    },\n    cost: 6 + reaches.length * 2,\n  };\n}\n\n/** The fields a text search looks in, as walks. Refuses a list that could never name any. */\nfunction textFields(names: unknown, context: Context, at: string): Reach[] {\n  if (!Array.isArray(names) || names.length === 0) throw new JqlError(`takes a non-empty list of field names, not ${describe(names)}`, join(at, \"$fields\"));\n  return names.map((name, index) => {\n    if (typeof name !== \"string\") throw new JqlError(`a field name is a string, not ${describe(name)}`, `${join(at, \"$fields\")}[${index}]`);\n    return resolveField(name, context, `${join(at, \"$fields\")}[${index}]`).reach;\n  });\n}\n\n/**\n * Whether the phrase appears in any string (or number) inside a value.\n *\n * Bounded by depth rather than by tracking what it has visited: a depth cap is free on\n * every document without a cycle, which is almost all of them, and still ends the walk on\n * one that has.\n */\nfunction containsText(value: unknown, found: (text: string) => boolean, numeric: boolean, depth: number): boolean {\n  if (typeof value === \"string\") return found(value);\n  if (typeof value === \"number\" || typeof value === \"bigint\") return numeric && found(String(value));\n  if (value === null || typeof value !== \"object\" || depth <= 0 || value instanceof Date) return false;\n  if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) if (containsText(value[i], found, numeric, depth - 1)) return true;\n    return false;\n  }\n  if (value instanceof Map || value instanceof Set) {\n    for (const item of value.values()) if (containsText(item, found, numeric, depth - 1)) return true;\n    return false;\n  }\n  const record = value as Record<string, unknown>;\n  for (const key in record) if (Object.hasOwn(record, key) && containsText(record[key], found, numeric, depth - 1)) return true;\n  return false;\n}\n\n/* ------------------------------------------------------------------------------------ */\n/* Combinators                                                                          */\n/* ------------------------------------------------------------------------------------ */\n\n/** Every part, cheapest first. Two and three parts get closures of their own rather than a loop. */\nfunction allOf(parts: Compiled[]): Compiled {\n  const real = parts.filter((part) => part !== ALWAYS);\n  if (real.includes(NOTHING)) return NOTHING;\n  if (real.length === 0) return ALWAYS;\n  if (real.length === 1) return real[0] as Compiled;\n  // Stable, so parts of equal cost keep the order they were written in.\n  real.sort((a, b) => a.cost - b.cost);\n  const cost = real.reduce((sum, part) => sum + part.cost, 0);\n  const tests = real.map((part) => part.test);\n  if (tests.length === 2) {\n    const [a, b] = tests as [Compiled[\"test\"], Compiled[\"test\"]];\n    return { test: (document) => a(document) && b(document), cost };\n  }\n  if (tests.length === 3) {\n    const [a, b, c] = tests as [Compiled[\"test\"], Compiled[\"test\"], Compiled[\"test\"]];\n    return { test: (document) => a(document) && b(document) && c(document), cost };\n  }\n  return {\n    test: (document) => {\n      for (let i = 0; i < tests.length; i++) if (!(tests[i] as Compiled[\"test\"])(document)) return false;\n      return true;\n    },\n    cost,\n  };\n}\n\n/** Any part, cheapest first. An empty list matches nothing, as an empty `$in` does. */\nfunction anyOf(parts: Compiled[]): Compiled {\n  const real = parts.filter((part) => part !== NOTHING);\n  if (real.includes(ALWAYS)) return ALWAYS;\n  if (real.length === 0) return NOTHING;\n  if (real.length === 1) return real[0] as Compiled;\n  real.sort((a, b) => a.cost - b.cost);\n  const cost = real.reduce((sum, part) => sum + part.cost, 0);\n  const tests = real.map((part) => part.test);\n  if (tests.length === 2) {\n    const [a, b] = tests as [Compiled[\"test\"], Compiled[\"test\"]];\n    return { test: (document) => a(document) || b(document), cost };\n  }\n  return {\n    test: (document) => {\n      for (let i = 0; i < tests.length; i++) if ((tests[i] as Compiled[\"test\"])(document)) return true;\n      return false;\n    },\n    cost,\n  };\n}\n\nfunction negate(part: Compiled): Compiled {\n  if (part === ALWAYS) return NOTHING;\n  if (part === NOTHING) return ALWAYS;\n  const test = part.test;\n  return { test: (document) => !test(document), cost: part.cost };\n}\n\n","/**\n * Writing a field onto a result object.\n *\n * `target[key] = value` looks harmless until the key is `__proto__`. Assignment goes\n * through the setter inherited from `Object.prototype`, which *replaces the object's\n * prototype* instead of adding a property — so the field the caller asked for is missing\n * and the object answers to names nobody put on it.\n *\n * It is reachable from data rather than from code: `JSON.parse('{\"__proto__\": …}')` makes\n * an own `__proto__` property, so any document read from a file, a request body or a store\n * can carry one. Projecting such a document used to lose that field and hand back a result\n * whose prototype was whatever the document said, which the projection's own test could not\n * see because the property it was looking for was genuinely there — on the prototype.\n *\n * Defining the property puts it where it was meant to go. Every other key takes the plain\n * assignment, so the guard costs one comparison on the path that builds results.\n */\nexport function setField(target: Record<string, unknown>, key: string, value: unknown): void {\n  if (key === \"__proto__\") {\n    Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });\n    return;\n  }\n  target[key] = value;\n}\n","import { type CompileOptions, compile } from \"./core.js\";\nimport { setField } from \"./internal/record.js\";\nimport type { Matcher, QueryLike, Source } from \"./types.js\";\n\n/**\n * Running a query over a collection.\n *\n * Every helper takes anything that holds items: an array, an array-like (a typed array,\n * `arguments`, a `NodeList`), any iterable (a `Set`, a generator), or a `Map` — which is\n * read by value, because a query about \"the user whose name is Ada\" is a question about\n * the users, not about the keys they happen to be filed under. `filterMap` and\n * `filterRecord` keep the keys for the times they matter.\n *\n * Arrays and array-likes are walked with an index rather than an iterator: the iterator\n * protocol allocates a result object per step, and on the collection sizes this library\n * is meant for, that allocation is most of the cost of the walk.\n */\n\ntype Items<T> = Source<T> | ReadonlyMap<unknown, T>;\n\n/** Calls `visit` for each item until it returns `true`. Returns the index it stopped at, or -1. */\nfunction walk<T>(source: Items<T>, visit: (item: T) => boolean): number {\n  if (Array.isArray(source)) {\n    for (let i = 0; i < source.length; i++) if (visit(source[i] as T)) return i;\n    return -1;\n  }\n  if (source instanceof Map) {\n    let i = 0;\n    for (const item of source.values()) {\n      if (visit(item as T)) return i;\n      i++;\n    }\n    return -1;\n  }\n  if (typeof (source as Iterable<T>)[Symbol.iterator] === \"function\") {\n    let i = 0;\n    for (const item of source as Iterable<T>) {\n      if (visit(item)) return i;\n      i++;\n    }\n    return -1;\n  }\n  const list = source as ArrayLike<T>;\n  for (let i = 0; i < list.length; i++) if (visit(list[i] as T)) return i;\n  return -1;\n}\n\n/** The first item that matches, or `undefined`. Stops at the first match. */\nexport function find<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V | undefined;\nexport function find<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;\nexport function find<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): T | undefined {\n  const test = compile(query, options);\n  let found: T | undefined;\n  walk(source, (item) => {\n    if (!test(item)) return false;\n    found = item;\n    return true;\n  });\n  return found;\n}\n\n/** The position of the first item that matches, or -1. For a `Map`, the position in insertion order. */\nexport function findIndex<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\nexport function findIndex<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\nexport function findIndex<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): number {\n  return walk(source, compile(query, options));\n}\n\n/** Every item that matches, in order, as a new array. */\nexport function filter<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V[];\nexport function filter<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\nexport function filter<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): T[] {\n  const test = compile(query, options);\n  const out: T[] = [];\n  walk(source, (item) => {\n    if (test(item)) out.push(item);\n    return false;\n  });\n  return out;\n}\n\n/** How many items match. Counts in place rather than building the list it would count. */\nexport function count<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\nexport function count<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\nexport function count<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): number {\n  const test = compile(query, options);\n  let total = 0;\n  walk(source, (item) => {\n    if (test(item)) total++;\n    return false;\n  });\n  return total;\n}\n\n/** Whether any item matches. Stops at the first. */\nexport function some<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\nexport function some<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\nexport function some<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): boolean {\n  return walk(source, compile(query, options)) !== -1;\n}\n\n/** Whether every item matches. True for an empty collection. Stops at the first that does not. */\nexport function every<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\nexport function every<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\nexport function every<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): boolean {\n  const test = compile(query, options);\n  return walk(source, (item) => !test(item)) === -1;\n}\n\n/** The matches and the rest, in one pass. */\nexport function partition<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [V[], V[]];\nexport function partition<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): [T[], T[]];\nexport function partition<T>(source: Items<T>, query: QueryLike<T, object>, options?: CompileOptions<object>): [T[], T[]] {\n  const test = compile(query, options);\n  const yes: T[] = [];\n  const no: T[] = [];\n  walk(source, (item) => {\n    (test(item) ? yes : no).push(item);\n    return false;\n  });\n  return [yes, no];\n}\n\n/** The entries of a `Map` whose value matches, as a new `Map` with the same keys. */\nexport function filterMap<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): Map<K, V> {\n  const test: Matcher<V> = compile(query, options);\n  const out = new Map<K, V>();\n  for (const [key, value] of source) if (test(value)) out.set(key, value);\n  return out;\n}\n\n/**\n * The properties of a plain object whose value matches, as a new object.\n *\n * Own enumerable properties only — the same ones `Object.entries` sees.\n */\nexport function filterRecord<V, Extra extends object = {}>(source: Readonly<Record<string, V>>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): Record<string, V> {\n  const test: Matcher<V> = compile(query, options);\n  const out: Record<string, V> = {};\n  for (const key of Object.keys(source)) {\n    const value = source[key] as V;\n    if (test(value)) setField(out as Record<string, unknown>, key, value);\n  }\n  return out;\n}\n\n/** The first value of a plain object that matches, with its key. */\nexport function findEntry<V, Extra extends object = {}>(source: Readonly<Record<string, V>>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [string, V] | undefined;\nexport function findEntry<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [K, V] | undefined;\nexport function findEntry<V>(source: ReadonlyMap<unknown, V> | Readonly<Record<string, V>>, query: QueryLike<V, object>, options?: CompileOptions<object>): [unknown, V] | undefined {\n  const test: Matcher<V> = compile(query, options);\n  if (source instanceof Map) {\n    for (const [key, value] of source) if (test(value)) return [key, value];\n    return undefined;\n  }\n  const record = source as Readonly<Record<string, V>>;\n  for (const key of Object.keys(record)) {\n    const value = record[key] as V;\n    if (test(value)) return [key, value];\n  }\n  return undefined;\n}\n","/**\n * One total order over every value a document can hold.\n *\n * A sort has to put *something* first when one item's field is a number and another's is\n * a string, or missing. The order is fixed and written down in the specification, so two\n * implementations sort a shared result the same way:\n *\n *   missing and null < numbers < strings < objects < booleans < dates\n *\n * Strings compare by UTF-16 code unit, not by locale. A locale-aware sort would put a\n * shared link's rows in a different order for each reader, which is worse than an order\n * that is merely unidiomatic for some of them. Objects compare equal to one another, so\n * their order is the order they arrived in.\n */\n\nfunction rank(value: unknown): number {\n  if (value === undefined || value === null) return 0;\n  switch (typeof value) {\n    case \"number\":\n    case \"bigint\":\n      return Number.isNaN(value) ? 0 : 1;\n    case \"string\":\n      return 2;\n    case \"boolean\":\n      return 4;\n    default:\n      return value instanceof Date ? 5 : 3;\n  }\n}\n\nexport function compareValues(a: unknown, b: unknown): number {\n  const ra = rank(a);\n  const rb = rank(b);\n  if (ra !== rb) return ra - rb;\n  switch (ra) {\n    case 1:\n    case 2:\n      return (a as number) < (b as number) ? -1 : (a as number) > (b as number) ? 1 : 0;\n    case 4:\n      return a === b ? 0 : a ? 1 : -1;\n    case 5:\n      return (a as Date).getTime() - (b as Date).getTime();\n    default:\n      return 0;\n  }\n}\n\n/**\n * The value an item sorts by, from everything its path reached.\n *\n * A path that reaches an array — or fans out over one — reaches several values. Ascending\n * sorts by the smallest of them and descending by the largest: an order\n * by \"tags\" puts first whatever has the tag that sorts first. Arrays nested past sixteen\n * levels are passed over, so an array that contains itself ends the walk.\n */\nexport function sortValue(values: readonly unknown[], descending: boolean, depth = 0): unknown {\n  let best: unknown;\n  let first = true;\n  for (const value of values) {\n    if (Array.isArray(value)) {\n      if (value.length === 0 || depth >= 16) continue;\n      const inner = sortValue(value, descending, depth + 1);\n      if (first || (descending ? compareValues(inner, best) > 0 : compareValues(inner, best) < 0)) best = inner;\n      first = false;\n      continue;\n    }\n    if (first || (descending ? compareValues(value, best) > 0 : compareValues(value, best) < 0)) best = value;\n    first = false;\n  }\n  return best;\n}\n","import { type CompileOptions, compile, reachField } from \"./core.js\";\nimport { JqlError } from \"./errors.js\";\nimport { didYouMean } from \"./internal/closest.js\";\nimport { compareValues, sortValue } from \"./internal/order.js\";\nimport { MAX_PATH_SEGMENTS, readOwn, splitPath } from \"./internal/path.js\";\nimport { setField } from \"./internal/record.js\";\nimport { describe, isPlainObject } from \"./internal/values.js\";\nimport type { Reach } from \"./internal/path.js\";\nimport type { FieldName, QueryLike, Request, Source } from \"./types.js\";\nimport { checkVocabulary, type Vocabulary } from \"./vocabulary.js\";\n\n/**\n * A whole request — which items, in which order, which page, which fields — in one pass.\n *\n * Two things make this cheaper than `filter` then `sort` then `slice`:\n *\n * - **Without a sort, it stops early.** The first page of matches is the first\n *   `skip + limit` of them, so the walk ends there instead of testing the rest.\n * - **With a sort and a limit, it keeps only the best `skip + limit`**, in a bounded heap,\n *   rather than sorting every match to keep a few: O(n log k) instead of O(n log n), and\n *   memory for k items rather than all of them. \"The ten slowest requests\" out of a\n *   million sorts ten.\n *\n * Sort keys are read once per match, not once per comparison.\n *\n * The sort is stable: items that tie on every key keep the order they arrived in, so\n * paging through a sorted result never shows an item twice or skips one.\n */\n\nconst REQUEST_KEYS = [\"where\", \"sort\", \"skip\", \"limit\", \"fields\", \"omit\"];\n\ninterface SortKey {\n  readonly reach: Reach;\n  readonly descending: boolean;\n}\n\ninterface Ranked<T> {\n  readonly item: T;\n  readonly keys: readonly unknown[];\n  readonly index: number;\n}\n\ntype Items<T> = Source<T> | ReadonlyMap<unknown, T>;\n\n/**\n * Runs a request. With `fields`, each result is a new object holding only those paths.\n *\n * A `Map` is read by value, like everywhere else in this library, so its overloads come\n * first: a `Map` also satisfies `Iterable<[key, value]>`, and without them the types would\n * describe a request over the pairs while the code ran one over the values.\n */\nexport function search<K, V, Extra extends object = {}>(\n  source: ReadonlyMap<K, V>,\n  request: Request<V, NoInfer<Extra>> & { readonly fields: readonly FieldName<V, NoInfer<Extra>>[] },\n  options?: CompileOptions<Extra>,\n): Record<string, unknown>[];\nexport function search<K, V, Extra extends object = {}>(\n  source: ReadonlyMap<K, V>,\n  request: Request<V, NoInfer<Extra>> & { readonly omit: readonly FieldName<V, NoInfer<Extra>>[] },\n  options?: CompileOptions<Extra>,\n): Partial<V>[];\nexport function search<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, request?: Request<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V[];\nexport function search<T, Extra extends object = {}>(\n  source: Items<T>,\n  request: Request<T, NoInfer<Extra>> & { readonly fields: readonly FieldName<T, NoInfer<Extra>>[] },\n  options?: CompileOptions<Extra>,\n): Record<string, unknown>[];\nexport function search<T, Extra extends object = {}>(\n  source: Items<T>,\n  request: Request<T, NoInfer<Extra>> & { readonly omit: readonly FieldName<T, NoInfer<Extra>>[] },\n  options?: CompileOptions<Extra>,\n): Partial<T>[];\nexport function search<T, Extra extends object = {}>(source: Items<T>, request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\nexport function search<T>(source: Items<T>, request: Request<T, object> = {}, options: CompileOptions<object> = {}): T[] | Record<string, unknown>[] {\n  // Through `planRequest`, which is what it is for: the paging, the heap and the projection\n  // are one copy, shared with the asynchronous helpers. Written out here as well — which it\n  // was — the two were free to drift, and \"the best twenty, skipping forty\" would have meant\n  // whatever each of them happened to say.\n  const plan = planRequest<T>(request, options);\n  const collect = plan.collect();\n  const test = plan.test;\n  each(source, (item, index) => {\n    if (test !== undefined && !test(item)) return false;\n    return collect.offer(item, index);\n  });\n  return plan.shape(collect.finish()) as T[];\n}\n\n/**\n * Everything about a request that does not depend on where the items come from.\n *\n * Pulled out so the asynchronous helpers run the same paging, the same heap and the same\n * projection as the synchronous ones. Two copies of \"the best twenty, skipping forty\"\n * would be two chances to page differently.\n */\nexport function planRequest<T>(request: Request<T, object>, options: CompileOptions<object>): {\n  collect: () => Collector<T>;\n  test: ((item: T) => boolean) | undefined;\n  shape: (items: T[]) => unknown[];\n} {\n  if (!isPlainObject(request)) throw new JqlError(`a request is an object, not ${describe(request)}`);\n  for (const key of Object.keys(request)) {\n    if (!REQUEST_KEYS.includes(key)) throw new JqlError(`\"${key}\" is not part of a request (${REQUEST_KEYS.join(\", \")})${didYouMean(key, REQUEST_KEYS)}`, key);\n  }\n  const vocabulary = checkVocabulary(options.vocabulary) as Vocabulary<unknown, object> | undefined;\n  const test = request.where === undefined ? undefined : compile(request.where as QueryLike<T, object>, options);\n  const skip = count(request.skip, \"skip\") ?? 0;\n  const limit = count(request.limit, \"limit\");\n  const keys = sortKeys(request.sort, vocabulary);\n  const project = request.fields === undefined ? undefined : projector(request.fields, vocabulary);\n  const drop = request.omit === undefined ? undefined : redactor(request.omit, vocabulary);\n  return {\n    collect: () => collector<T>(keys, skip, limit),\n    test,\n    shape: (items) => {\n      const projected = project === undefined ? items : items.map(project);\n      return drop === undefined ? projected : projected.map(drop);\n    },\n  };\n}\n\n/** Gathers the page as items arrive. `offer` returns true once nothing further can change the answer. */\nexport interface Collector<T> {\n  offer(item: T, index: number): boolean;\n  finish(): T[];\n}\n\nfunction collector<T>(keys: readonly SortKey[], skip: number, limit: number | undefined): Collector<T> {\n  return keys.length === 0 ? inOrder<T>(skip, limit) : ranked<T>(keys, skip, limit);\n}\n\nfunction count(value: unknown, name: string): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isInteger(value) || value < 0) {\n    throw new JqlError(`is a whole number of items, zero or more, not ${describe(value)}`, name);\n  }\n  return value;\n}\n\nfunction sortKeys(sort: unknown, vocabulary: Vocabulary<unknown, object> | undefined): SortKey[] {\n  if (sort === undefined) return [];\n  if (!isPlainObject(sort)) throw new JqlError(`is an object of field names to directions, not ${describe(sort)}`, \"sort\");\n  return Object.keys(sort).map((name) => {\n    const direction = sort[name];\n    const at = `sort.${name}`;\n    if (direction !== 1 && direction !== -1 && direction !== \"asc\" && direction !== \"desc\") {\n      throw new JqlError(`a direction is 1, -1, \"asc\" or \"desc\", not ${describe(direction)}`, at);\n    }\n    return { reach: reachField(name, vocabulary, at), descending: direction === -1 || direction === \"desc\" };\n  });\n}\n\n/** Calls `visit` with each item and its position until it returns `true`. */\nfunction each<T>(source: Items<T>, visit: (item: T, index: number) => boolean): void {\n  if (Array.isArray(source)) {\n    for (let i = 0; i < source.length; i++) if (visit(source[i] as T, i)) return;\n    return;\n  }\n  const iterable: Iterable<T> | undefined =\n    source instanceof Map ? (source.values() as Iterable<T>) : typeof (source as Iterable<T>)[Symbol.iterator] === \"function\" ? (source as Iterable<T>) : undefined;\n  if (iterable === undefined) {\n    const list = source as ArrayLike<T>;\n    for (let i = 0; i < list.length; i++) if (visit(list[i] as T, i)) return;\n    return;\n  }\n  let i = 0;\n  for (const item of iterable) if (visit(item, i++)) return;\n}\n\n/** Without a sort, the page is the first `skip + limit` matches, and the walk can stop there. */\nfunction inOrder<T>(skip: number, limit: number | undefined): Collector<T> {\n  const out: T[] = [];\n  let passed = 0;\n  return {\n    offer(item) {\n      if (limit === 0) return true;\n      if (passed < skip) {\n        passed++;\n        return false;\n      }\n      out.push(item);\n      return limit !== undefined && out.length >= limit;\n    },\n    finish: () => out,\n  };\n}\n\n/** With a sort and a limit, only the best `skip + limit` are ever held. */\nfunction ranked<T>(keys: readonly SortKey[], skip: number, limit: number | undefined): Collector<T> {\n  const compare = (a: Ranked<T>, b: Ranked<T>): number => {\n    for (let i = 0; i < keys.length; i++) {\n      const order = compareValues(a.keys[i], b.keys[i]);\n      if (order !== 0) return (keys[i] as SortKey).descending ? -order : order;\n    }\n    return a.index - b.index;\n  };\n  const keep = limit === undefined ? Number.POSITIVE_INFINITY : skip + limit;\n  const heap: Ranked<T>[] = [];\n  return {\n    offer(item, index) {\n      if (limit === 0) return true;\n      const entry: Ranked<T> = { item, keys: keys.map((key) => keyOf(item, key)), index };\n      if (heap.length < keep) {\n        heap.push(entry);\n        if (keep !== Number.POSITIVE_INFINITY) siftUp(heap, heap.length - 1, compare);\n      } else if (compare(entry, heap[0] as Ranked<T>) < 0) {\n        heap[0] = entry;\n        siftDown(heap, 0, compare);\n      }\n      return false;\n    },\n    finish() {\n      heap.sort(compare);\n      return heap.slice(skip).map((entry) => entry.item);\n    },\n  };\n}\n\nfunction keyOf(item: unknown, key: SortKey): unknown {\n  const values: unknown[] = [];\n  key.reach(item, (value) => {\n    values.push(value);\n    return false;\n  });\n  return sortValue(values, key.descending);\n}\n\n/* A max-heap under `compare`: the root is the item that would be dropped first. */\n\nfunction siftUp<T>(heap: T[], at: number, compare: (a: T, b: T) => number): void {\n  let child = at;\n  while (child > 0) {\n    const parent = (child - 1) >> 1;\n    if (compare(heap[child] as T, heap[parent] as T) <= 0) return;\n    [heap[child], heap[parent]] = [heap[parent] as T, heap[child] as T];\n    child = parent;\n  }\n}\n\nfunction siftDown<T>(heap: T[], at: number, compare: (a: T, b: T) => number): void {\n  let parent = at;\n  for (;;) {\n    const left = parent * 2 + 1;\n    const right = left + 1;\n    let largest = parent;\n    if (left < heap.length && compare(heap[left] as T, heap[largest] as T) > 0) largest = left;\n    if (right < heap.length && compare(heap[right] as T, heap[largest] as T) > 0) largest = right;\n    if (largest === parent) return;\n    [heap[parent], heap[largest]] = [heap[largest] as T, heap[parent] as T];\n    parent = largest;\n  }\n}\n\n/* ------------------------------------------------------------------------------------ */\n/* Projection                                                                           */\n/* ------------------------------------------------------------------------------------ */\n\ntype Tree = Map<string, Tree | true>;\n\n/**\n * Keeps the named paths of each item and nothing else.\n *\n * The result has the document's own shape — `address.city` comes back as\n * `{ address: { city } }` — so a caller reads a projected item exactly as it would the\n * whole one. An array on the way is kept as an array of the projected elements. A\n * vocabulary's computed field comes back under its own name.\n */\nfunction projector(fields: unknown, vocabulary: Vocabulary<unknown, object> | undefined): (item: unknown) => Record<string, unknown> {\n  if (!Array.isArray(fields)) throw new JqlError(`is a list of field names, not ${describe(fields)}`, \"fields\");\n  const tree: Tree = new Map();\n  const computed: [string, (item: unknown) => unknown][] = [];\n  fields.forEach((name, index) => {\n    const at = `fields[${index}]`;\n    if (typeof name !== \"string\") throw new JqlError(`a field name is a string, not ${describe(name)}`, at);\n    const field = vocabulary?.lookup.get(name.toLowerCase());\n    if (field?.get !== undefined) {\n      computed.push([field.name, field.get as (item: unknown) => unknown]);\n      return;\n    }\n    const keys = splitPath(field?.path ?? name);\n    if (typeof keys === \"string\") throw new JqlError(keys, at);\n    // `for`, not `forEach`: skipping a segment has to stop the walk, and a `return` inside\n    // the callback only ended that step — leaving the rest of the path attached at the top\n    // level, so `fields: [\"a\", \"a.b\"]` also emitted whatever `b` the item had of its own.\n    let node = tree;\n    for (let position = 0; position < keys.length; position++) {\n      const key = keys[position] as string;\n      const existing = node.get(key);\n      // A whole subtree is already being kept here; anything under it is already included.\n      if (existing === true) break;\n      if (position === keys.length - 1) {\n        // A whole value asked for alongside part of it: the whole wins.\n        node.set(key, true);\n        break;\n      }\n      if (existing === undefined) {\n        const child: Tree = new Map();\n        node.set(key, child);\n        node = child;\n      } else node = existing;\n    }\n  });\n  return (item) => {\n    const out = (pick(item, tree, 0) ?? {}) as Record<string, unknown>;\n    for (const [name, get] of computed) setField(out, name, get(item));\n    return out;\n  };\n}\n\n/**\n * Drops the named paths from each result.\n *\n * A copy, never a change to the item: a request is a question, and a question that edited\n * the store it was asked of would be a very surprising one. Only the objects on the way to\n * a dropped field are copied; everything else is shared with the item, so redacting one\n * field of a large record does not duplicate the record.\n */\nfunction redactor(omit: unknown, vocabulary: Vocabulary<unknown, object> | undefined): (item: unknown) => unknown {\n  if (!Array.isArray(omit)) throw new JqlError(`is a list of field names, not ${describe(omit)}`, \"omit\");\n  const tree: Tree = new Map();\n  omit.forEach((name, index) => {\n    const at = `omit[${index}]`;\n    if (typeof name !== \"string\") throw new JqlError(`a field name is a string, not ${describe(name)}`, at);\n    const field = vocabulary?.lookup.get(name.toLowerCase());\n    // A computed field has no place in the item, so it is dropped by its own name — which\n    // is where `fields` put it.\n    const keys = field?.get !== undefined ? [field.name] : splitPath(field?.path ?? name);\n    if (typeof keys === \"string\") throw new JqlError(keys, at);\n    let node = tree;\n    for (let position = 0; position < keys.length; position++) {\n      const key = keys[position] as string;\n      if (position === keys.length - 1) {\n        node.set(key, true);\n        break;\n      }\n      const existing = node.get(key);\n      // The whole subtree is already going; nothing under it needs naming.\n      if (existing === true) break;\n      if (existing === undefined) {\n        const child: Tree = new Map();\n        node.set(key, child);\n        node = child;\n      } else node = existing;\n    }\n  });\n  return (item) => without(item, tree, 0);\n}\n\n/**\n * How deep `omit` will walk.\n *\n * Past this it refuses rather than stopping: a redaction that quietly gave up returned the\n * field it was asked to remove, which is the one outcome this must never have. No item\n * anybody stores is five hundred levels deep.\n */\nconst MAX_REDACT_DEPTH = 512;\n\nfunction without(value: unknown, tree: Tree, depth: number): unknown {\n  if (depth > MAX_REDACT_DEPTH) {\n    throw new JqlError(`an item nests deeper than ${MAX_REDACT_DEPTH} levels, so it cannot be redacted; nothing was dropped from it`, \"omit\");\n  }\n  if (value === null || typeof value !== \"object\") return value;\n  if (Array.isArray(value)) {\n    let changed = false;\n    const copy = value.map((element) => {\n      const kept = without(element, tree, depth + 1);\n      if (kept !== element) changed = true;\n      return kept;\n    });\n    return changed ? copy : value;\n  }\n  if (value instanceof Map) {\n    let changed = false;\n    const copy = new Map<unknown, unknown>();\n    for (const [key, held] of value) {\n      const sub = typeof key === \"string\" ? tree.get(key) : undefined;\n      if (sub === true) {\n        changed = true;\n        continue;\n      }\n      const kept = sub === undefined ? held : without(held, sub, depth + 1);\n      if (kept !== held) changed = true;\n      copy.set(key, kept);\n    }\n    return changed ? copy : value;\n  }\n  const record = value as Record<string, unknown>;\n  const keys = Object.keys(record);\n  // Nothing here is named at all: hand back the object itself rather than a copy of it.\n  if (!keys.some((key) => tree.has(key))) return value;\n  const out: Record<string, unknown> = {};\n  let changed = false;\n  for (const key of keys) {\n    const sub = tree.get(key);\n    if (sub === true) {\n      changed = true;\n      continue;\n    }\n    const held = record[key];\n    const kept = sub === undefined ? held : without(held, sub, depth + 1);\n    if (kept !== held) changed = true;\n    setField(out, key, kept);\n  }\n  // A path that named something this item does not have has dropped nothing, and an item\n  // with nothing dropped is the item: redacting a field absent from half the rows should\n  // not copy those rows.\n  return changed ? out : value;\n}\n\n/**\n * The named paths of one item, as a new object.\n *\n * The depth it stops at is the longest path there can be, because the tree it walks is made\n * of paths and can be no deeper than the longest of them. It used to stop at sixty-four,\n * which was shorter than a path is allowed to be: a query matched on `a.b.c…` past that\n * depth and the projection quietly left the field out of the result, so the same path\n * meant two different things in one request.\n */\nfunction pick(value: unknown, tree: Tree, depth: number): Record<string, unknown> | undefined {\n  if (value === null || typeof value !== \"object\" || depth > MAX_PATH_SEGMENTS) return undefined;\n  const out: Record<string, unknown> = {};\n  for (const [key, sub] of tree) {\n    const found = readOwn(value, key);\n    if (found === undefined) continue;\n    if (sub === true) setField(out, key, found);\n    else if (Array.isArray(found)) setField(out, key, found.map((element) => pick(element, sub, depth + 1)).filter((element) => element !== undefined));\n    else {\n      const inner = pick(found, sub, depth + 1);\n      if (inner !== undefined) setField(out, key, inner);\n    }\n  }\n  return out;\n}\n","import { count, every, filter, filterMap, find, findIndex, partition, some } from \"./collections.js\";\nimport { compile, type CompileOptions } from \"./core.js\";\nimport { search } from \"./search.js\";\nimport type { QueryLike, Request, Source } from \"./types.js\";\n\n/**\n * The query methods on `Array`, `Map` and `Set`.\n *\n * Patching a built-in is a decision for the application, never for a library it imports,\n * so nothing here runs on import: `install()` does it, and the `@osqd/jql/global` entry\n * calls `install()` and adds the matching types in one line. A package that depends on JQL\n * uses the functions and leaves the prototypes alone.\n *\n * Every method is defined non-enumerable, so a `for…in` over an array — which nobody\n * should write, and some code does — sees nothing new.\n *\n * `install` refuses to overwrite a method of the same name it did not put there. Two\n * libraries both defining `Array.prototype.jqlSearch` would otherwise leave whichever\n * loaded last in charge, and the other one's callers running code they never wrote.\n */\n\n/**\n * The mark that says a method on a built-in is this library's.\n *\n * `Symbol.for` rather than a set held in this module, because the question is asked across\n * copies: npm puts two copies of a package in one process whenever two dependencies want\n * different versions of it, and a set in one copy knows nothing about the other copy's\n * methods. The second copy's `import \"@osqd/jql/global\"` used to throw \"already defined by\n * something else\" — naming JQL itself as the intruder, at import time, which takes the whole\n * application down over methods that do the same thing.\n *\n * So a marked method is recognised whichever copy installed it, and the copy that got there\n * first keeps the field. Both copies answer the same queries the same way: what a method\n * means is pinned by the conformance suite, not by which copy of it is in place.\n */\nconst MARK = Symbol.for(\"@osqd/jql.method\");\n\ntype Methods = Record<string, (...args: never[]) => unknown>;\n\n/** Whether this is a JQL method, from this copy of the library or from another. */\nfunction isOurs(value: unknown): boolean {\n  return typeof value === \"function\" && (value as unknown as Record<symbol, unknown>)[MARK] === true;\n}\n\nconst ARRAY_METHODS: Methods = {\n  jqlSearch<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return find(this, query, options);\n  },\n  jqlFilter<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return filter(this, query, options);\n  },\n  jqlCount<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return count(this, query, options);\n  },\n  jqlSome<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return some(this, query, options);\n  },\n  jqlEvery<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return every(this, query, options);\n  },\n  jqlFindIndex<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return findIndex(this, query, options);\n  },\n  jqlPartition<T>(this: T[], query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return partition(this, query, options);\n  },\n  jqlQuery<T>(this: T[], request?: Request<T, object>, options?: CompileOptions<object>) {\n    return search(this, request, options);\n  },\n};\n\nconst ARRAY_STATICS: Methods = {\n  jqlSearch<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return find(source, query, options);\n  },\n  jqlFilter<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return filter(source, query, options);\n  },\n  jqlCount<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return count(source, query, options);\n  },\n  jqlSome<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return some(source, query, options);\n  },\n  jqlEvery<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return every(source, query, options);\n  },\n  jqlFindIndex<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return findIndex(source, query, options);\n  },\n  jqlPartition<T>(source: Source<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return partition(source, query, options);\n  },\n  jqlQuery<T>(source: Source<T>, request?: Request<T, object>, options?: CompileOptions<object>) {\n    return search(source, request, options);\n  },\n};\n\nconst MAP_METHODS: Methods = {\n  jqlSearch<K, V>(this: Map<K, V>, query: QueryLike<V, object>, options?: CompileOptions<object>) {\n    return find(this, query, options);\n  },\n  jqlFilter<K, V>(this: Map<K, V>, query: QueryLike<V, object>, options?: CompileOptions<object>) {\n    return filterMap(this, query, options);\n  },\n  jqlCount<K, V>(this: Map<K, V>, query: QueryLike<V, object>, options?: CompileOptions<object>) {\n    return count(this, query, options);\n  },\n};\n\nconst SET_METHODS: Methods = {\n  jqlSearch<T>(this: Set<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return find(this, query, options);\n  },\n  jqlFilter<T>(this: Set<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    const test = compile(query, options);\n    const out = new Set<T>();\n    for (const item of this) if (test(item)) out.add(item);\n    return out;\n  },\n  jqlCount<T>(this: Set<T>, query: QueryLike<T, object>, options?: CompileOptions<object>) {\n    return count(this, query, options);\n  },\n};\n\nconst TARGETS: readonly [object, Methods, string][] = [\n  [Array.prototype, ARRAY_METHODS, \"Array.prototype\"],\n  [Array, ARRAY_STATICS, \"Array\"],\n  [Map.prototype, MAP_METHODS, \"Map.prototype\"],\n  [Set.prototype, SET_METHODS, \"Set.prototype\"],\n];\n\nfor (const [, methods] of TARGETS) {\n  for (const method of Object.values(methods)) Object.defineProperty(method, MARK, { value: true });\n}\n\n/**\n * Adds the methods.\n *\n * Safe to call more than once, and safe when another copy of JQL has already installed\n * them: whichever copy got there first keeps the field. Throws only for a method of the\n * same name that is not JQL's at all, because installing over that would silently change\n * what its callers run.\n */\nexport function install(): void {\n  for (const [target, methods, label] of TARGETS) {\n    for (const name of Object.keys(methods)) {\n      const existing = Object.getOwnPropertyDescriptor(target, name);\n      if (existing !== undefined && !isOurs(existing.value)) {\n        throw new Error(`${label}.${name} is already defined by something else; installing over it would silently change what its callers run`);\n      }\n    }\n  }\n  for (const [target, methods] of TARGETS) {\n    for (const [name, method] of Object.entries(methods)) {\n      if (Object.getOwnPropertyDescriptor(target, name) !== undefined) continue;\n      Object.defineProperty(target, name, { value: method, writable: true, configurable: true, enumerable: false });\n    }\n  }\n}\n\n/** Removes JQL's methods — this copy's, and any another copy of it installed. */\nexport function uninstall(): void {\n  for (const [target, methods] of TARGETS) {\n    for (const name of Object.keys(methods)) {\n      const existing = Object.getOwnPropertyDescriptor(target, name);\n      if (existing !== undefined && isOurs(existing.value)) Reflect.deleteProperty(target, name);\n    }\n  }\n}\n","import { install } from \"./array.js\";\nimport type { CompileOptions } from \"./core.js\";\nimport type { FieldName, QueryLike, Request, Source } from \"./types.js\";\n\n/**\n * `import \"@osqd/jql/global\"` — the query methods on `Array`, `Map` and `Set`, with types.\n *\n * The one module in the package with a side effect, and the only one that declares the\n * methods to TypeScript. The declarations live here rather than beside `install()` on\n * purpose: if importing the engine added `jqlSearch` to every array's type without adding\n * it to every array, the compiler would promise a method that throws \"is not a function\"\n * at run time — present, type-checked and missing.\n *\n * ```ts\n * import \"@osqd/jql/global\";\n *\n * const users = [{ id: 1, name: \"Ada\" }, { id: 2, name: \"Grace\" }];\n * users.jqlSearch({ id: 2 });                       // { id: 2, name: \"Grace\" }\n * Array.jqlSearch(users, { name: { $startsWith: \"A\" } });\n * ```\n */\n\ninstall();\n\nexport { install, uninstall } from \"./array.js\";\n\ndeclare global {\n  interface ReadonlyArray<T> {\n    /** The first item matching the query, or `undefined`. */\n    jqlSearch<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;\n    /** Every item matching the query, as a new array. */\n    jqlFilter<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n    /** How many items match. */\n    jqlCount<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    /** Whether any item matches. */\n    jqlSome<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    /** Whether every item matches. True when there are none. */\n    jqlEvery<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    /** The position of the first match, or -1. */\n    jqlFindIndex<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    /** The matches and the rest. */\n    jqlPartition<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): [T[], T[]];\n    /** A whole request: `where`, `sort`, `skip`, `limit`, `fields`, `omit`. */\n    jqlQuery<Extra extends object = {}>(request: Request<T, NoInfer<Extra>> & { readonly fields: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Record<string, unknown>[];\n    /** With `omit`, each result is a copy without those paths — which is `Partial<T>`, not `T`. */\n    jqlQuery<Extra extends object = {}>(request: Request<T, NoInfer<Extra>> & { readonly omit: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Partial<T>[];\n    jqlQuery<Extra extends object = {}>(request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n  }\n\n  interface Array<T> {\n    jqlSearch<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;\n    jqlFilter<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n    jqlCount<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlSome<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlEvery<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlFindIndex<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlPartition<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): [T[], T[]];\n    jqlQuery<Extra extends object = {}>(request: Request<T, NoInfer<Extra>> & { readonly fields: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Record<string, unknown>[];\n    jqlQuery<Extra extends object = {}>(request: Request<T, NoInfer<Extra>> & { readonly omit: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Partial<T>[];\n    jqlQuery<Extra extends object = {}>(request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n  }\n\n  interface ArrayConstructor {\n    /** The first item of any array, array-like, iterable or `Map` (by value) matching the query. */\n    jqlSearch<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V | undefined;\n    jqlSearch<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;\n    jqlFilter<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V[];\n    jqlFilter<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n    jqlCount<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlCount<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlSome<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlSome<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlEvery<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlEvery<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;\n    jqlFindIndex<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlFindIndex<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n    jqlPartition<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [V[], V[]];\n    jqlPartition<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): [T[], T[]];\n    jqlQuery<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, request: Request<V, NoInfer<Extra>> & { readonly fields: readonly FieldName<V, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Record<string, unknown>[];\n    jqlQuery<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, request: Request<V, NoInfer<Extra>> & { readonly omit: readonly FieldName<V, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Partial<V>[];\n    jqlQuery<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, request?: Request<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V[];\n    jqlQuery<T, Extra extends object = {}>(source: Source<T>, request: Request<T, NoInfer<Extra>> & { readonly fields: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Record<string, unknown>[];\n    jqlQuery<T, Extra extends object = {}>(source: Source<T>, request: Request<T, NoInfer<Extra>> & { readonly omit: readonly FieldName<T, NoInfer<Extra>>[] }, options?: CompileOptions<Extra>): Partial<T>[];\n    jqlQuery<T, Extra extends object = {}>(source: Source<T>, request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];\n  }\n\n  interface Map<K, V> {\n    /** The first value matching the query. */\n    jqlSearch<Extra extends object = {}>(query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V | undefined;\n    /** The entries whose value matches, as a new `Map`. */\n    jqlFilter<Extra extends object = {}>(query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): Map<K, V>;\n    jqlCount<Extra extends object = {}>(query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n  }\n\n  interface Set<T> {\n    jqlSearch<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;\n    /** The members that match, as a new `Set`. */\n    jqlFilter<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Set<T>;\n    jqlCount<Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;\n  }\n}\n"]}