@osqd/jql 0.1.1

package/conformance/cases.json

@@ -0,0 +1,290 @@
+{
+  "about": "The JQL conformance suite. Every implementation of the language must produce exactly these answers. Each case runs `query` over the named document set and lists the positions of the documents that match, in order; a case with `error` must be refused, and `at` is where in the query the refusal points. The documents are plain JSON, so nothing here depends on JavaScript.",
+  "version": "1.1",
+  "documents": {
+    "people": [
+      { "id": "ada", "name": "Ada Lovelace", "age": 36, "born": "1815-12-10", "tags": ["math", "poetry"], "address": { "city": "London", "zip": "W1" }, "languages": [{ "name": "English", "level": 5 }, { "name": "French", "level": 3 }], "active": true, "score": null },
+      { "id": "grace", "name": "Grace Hopper", "age": 85, "born": "1906-12-09", "tags": ["navy", "cobol"], "address": { "city": "New York" }, "languages": [{ "name": "English", "level": 5 }], "active": false },
+      { "id": "alan", "name": "Alan Turing", "age": 41, "born": "1912-06-23", "tags": ["math", "crypto"], "address": { "city": "Manchester", "zip": "M1" }, "languages": [{ "name": "English", "level": 5 }, { "name": "German", "level": 2 }], "active": true, "score": 99 },
+      { "id": "linus", "name": "Linus Torvalds", "age": 56, "tags": [], "address": null, "active": true, "score": 7.5, "nick": "torvalds" }
+    ],
+    "numbers": [
+      1,
+      5,
+      10,
+      -3,
+      2.5
+    ],
+    "mixed": [
+      1,
+      "1",
+      "10",
+      9,
+      null,
+      true,
+      [1, 2],
+      { "a": 1 }
+    ],
+    "hosts": [
+      { "actor": "1.2.3.4" },
+      { "actor": "1.2.3.45" },
+      { "actor": "11.2.3.4" },
+      { "actor": "1.2.3.0/24" },
+      { "actor": "203.0.113.9" }
+    ],
+    "rows": [
+      { "id": 0, "group": "b", "score": 2, "tags": ["m", "a"] },
+      { "id": 1, "group": "a", "score": 2, "tags": ["z"] },
+      { "id": 2, "group": "b", "score": null, "tags": [] },
+      { "id": 3, "group": "a", "score": 9, "tags": ["b", "y"] },
+      { "id": 4, "group": "a", "tags": ["c"] }
+    ],
+    "named": [
+      { "id": 1, "__proto__": { "polluted": "no" } }
+    ],
+    "pairs": [
+      { "id": 0, "in": 100, "out": 900 },
+      { "id": 1, "in": 900, "out": 100 },
+      { "id": 2, "in": 100, "out": 100 },
+      { "id": 3, "out": 5 },
+      { "id": 4, "in": "5", "out": 5 },
+      { "id": 5, "in": [1, 9], "out": 5 }
+    ],
+    "texts": [
+      { "s": "abc" },
+      { "s": "☃" },
+      { "s": "😀" },
+      { "s": "a*b" }
+    ],
+    "stamps": [
+      { "t": "2020-12-31" },
+      { "t": "2020-12-31T10:00:00Z" },
+      { "t": "2020-12-31 10:00:00" },
+      { "t": "12/31/2020" },
+      { "t": "Mar 5 2021" },
+      { "t": 1609372800000 },
+      { "t": "5" }
+    ],
+    "letters": [
+      { "s": "𝐀𝐁" },
+      { "s": "𝐀.b" },
+      { "s": "ab" },
+      { "s": "a.b" }
+    ],
+    "events": [
+      { "at": "2026-09-22T11:30:00Z" },
+      { "at": "2026-09-22T09:00:00Z" },
+      { "at": "2026-09-15T12:00:00Z" }
+    ],
+    "values": [
+      { "v": "b" },
+      { "v": true },
+      { "v": 3 },
+      {},
+      { "v": null },
+      { "v": { "a": 1 } },
+      { "v": 1 },
+      { "v": "a" }
+    ],
+    "lines": [
+      [{ "sku": "pen" }, { "sku": "ink" }],
+      [{ "sku": "pad" }],
+      [],
+      [3, 4],
+      { "sku": "pen" }
+    ],
+    "matrix": [
+      { "id": 0, "cells": [[1, 2], [3, 4]] },
+      { "id": 1, "cells": [[5]] },
+      { "id": 2, "points": [{ "x": 1, "y": 2 }, { "x": 3, "y": 1 }] },
+      { "id": 3, "points": [{ "x": 1, "y": 1 }] }
+    ]
+  },
+  "requests": [
+    { "group": "sort", "name": "ascending, with missing and null first and ties in arrival order", "documents": "rows", "request": { "sort": { "score": 1 } }, "matches": [2, 4, 0, 1, 3] },
+    { "group": "sort", "name": "descending reverses the values but not the ties", "documents": "rows", "request": { "sort": { "score": -1 } }, "matches": [3, 0, 1, 2, 4] },
+    { "group": "sort", "name": "asc and desc spelled out", "documents": "rows", "request": { "sort": { "score": "asc" } }, "matches": [2, 4, 0, 1, 3] },
+    { "group": "sort", "name": "the second key breaks the first key's ties", "documents": "rows", "request": { "sort": { "group": "asc", "score": "desc" } }, "matches": [3, 1, 4, 0, 2] },
+    { "group": "sort", "name": "one order across every type", "documents": "values", "request": { "sort": { "v": 1 } }, "matches": [3, 4, 6, 2, 7, 0, 5, 1] },
+    { "group": "sort", "name": "an array sorts by its least element ascending", "documents": "rows", "request": { "sort": { "tags": 1 } }, "matches": [2, 0, 3, 4, 1] },
+    { "group": "sort", "name": "and by its greatest descending", "documents": "rows", "request": { "sort": { "tags": -1 } }, "matches": [1, 3, 0, 4, 2] },
+    { "group": "paging", "name": "skip and limit walk a sorted result", "documents": "rows", "request": { "sort": { "id": 1 }, "skip": 1, "limit": 2 }, "matches": [1, 2] },
+    { "group": "paging", "name": "the next page does not repeat or drop an item", "documents": "rows", "request": { "sort": { "score": 1 }, "skip": 2, "limit": 2 }, "matches": [0, 1] },
+    { "group": "paging", "name": "a limit without a sort keeps the given order", "documents": "rows", "request": { "where": { "group": "a" }, "limit": 2 }, "matches": [1, 3] },
+    { "group": "paging", "name": "a limit of zero returns nothing", "documents": "rows", "request": { "limit": 0 }, "matches": [] },
+    { "group": "paging", "name": "skipping past the end returns nothing", "documents": "rows", "request": { "sort": { "id": 1 }, "skip": 99 }, "matches": [] },
+    { "group": "paging", "name": "where, sort, skip and limit together", "documents": "rows", "request": { "where": { "score": { "$exists": true } }, "sort": { "score": -1 }, "skip": 1, "limit": 2 }, "matches": [0, 1] },
+    { "group": "projection", "name": "keeps the named paths in the document's own shape", "documents": "people", "request": { "where": { "id": "ada" }, "fields": ["id", "address.city", "languages.name"] }, "projection": [{ "id": "ada", "address": { "city": "London" }, "languages": [{ "name": "English" }, { "name": "French" }] }] },
+    { "group": "projection", "name": "a path and its parent keep the parent whole", "documents": "people", "request": { "where": { "id": "ada" }, "fields": ["address.city", "address"] }, "projection": [{ "address": { "city": "London", "zip": "W1" } }] },
+    { "group": "projection", "name": "a missing path is left out", "documents": "people", "request": { "where": { "id": "linus" }, "fields": ["nick", "address.city"] }, "projection": [{ "nick": "torvalds" }] },
+    { "group": "projection", "name": "a field is data whatever it is called", "documents": "named", "request": { "fields": ["__proto__", "id"] }, "projection": [{ "__proto__": { "polluted": "no" }, "id": 1 }] },
+    { "group": "redaction", "name": "drops the named fields from each result", "documents": "people", "request": { "where": { "id": "grace" }, "omit": ["age", "born", "tags", "languages", "active"] }, "projection": [{ "id": "grace", "name": "Grace Hopper", "address": { "city": "New York" } }] },
+    { "group": "redaction", "name": "drops a nested path and leaves the rest of the object", "documents": "people", "request": { "where": { "id": "ada" }, "fields": ["id", "address"], "omit": ["address.zip"] }, "projection": [{ "id": "ada", "address": { "city": "London" } }] },
+    { "group": "redaction", "name": "drops a path through an array, from every element", "documents": "people", "request": { "where": { "id": "ada" }, "fields": ["languages"], "omit": ["languages.level"] }, "projection": [{ "languages": [{ "name": "English" }, { "name": "French" }] }] },
+    { "group": "redaction", "name": "drops nothing for a path the item does not have", "documents": "people", "request": { "where": { "id": "linus" }, "fields": ["id", "nick"], "omit": ["address.zip"] }, "projection": [{ "id": "linus", "nick": "torvalds" }] },
+    { "group": "redaction", "name": "applies after fields, so a kept subtree can lose part of itself", "documents": "people", "request": { "where": { "id": "alan" }, "fields": ["address"], "omit": ["address.city"] }, "projection": [{ "address": { "zip": "M1" } }] },
+    { "group": "refusals", "name": "an unknown key in a request", "documents": "rows", "request": { "limt": 1 }, "error": true, "at": "limt" },
+    { "group": "refusals", "name": "a limit that is not a whole number", "documents": "rows", "request": { "limit": 1.5 }, "error": true, "at": "limit" },
+    { "group": "refusals", "name": "a negative skip", "documents": "rows", "request": { "skip": -1 }, "error": true, "at": "skip" },
+    { "group": "refusals", "name": "a direction that is not one", "documents": "rows", "request": { "sort": { "id": "up" } }, "error": true, "at": "sort.id" },
+    { "group": "refusals", "name": "a field name in omit that is not a string", "documents": "rows", "request": { "omit": [5] }, "error": true, "at": "omit[0]" }
+  ],
+  "cases": [
+    { "group": "equality", "name": "an empty query matches everything", "documents": "people", "query": {}, "matches": [0, 1, 2, 3] },
+    { "group": "equality", "name": "a literal is equality", "documents": "people", "query": { "id": "grace" }, "matches": [1] },
+    { "group": "equality", "name": "several fields must all hold", "documents": "people", "query": { "active": true, "age": 41 }, "matches": [2] },
+    { "group": "equality", "name": "$eq says the same thing", "documents": "people", "query": { "age": { "$eq": 36 } }, "matches": [0] },
+    { "group": "equality", "name": "a nested path", "documents": "people", "query": { "address.city": "London" }, "matches": [0] },
+    { "group": "equality", "name": "a value compared with an array matches any element", "documents": "people", "query": { "tags": "math" }, "matches": [0, 2] },
+    { "group": "equality", "name": "an array literal matches the whole array, in order", "documents": "people", "query": { "tags": ["math", "poetry"] }, "matches": [0] },
+    { "group": "equality", "name": "an array literal in another order does not", "documents": "people", "query": { "tags": ["poetry", "math"] }, "matches": [] },
+    { "group": "equality", "name": "an empty array literal matches an empty array", "documents": "people", "query": { "tags": [] }, "matches": [3] },
+    { "group": "equality", "name": "an object literal matches keys in any order", "documents": "people", "query": { "address": { "zip": "W1", "city": "London" } }, "matches": [0] },
+    { "group": "equality", "name": "an object literal needs every key and no more", "documents": "people", "query": { "address": { "city": "London" } }, "matches": [] },
+    { "group": "equality", "name": "null matches null and missing", "documents": "people", "query": { "score": null }, "matches": [0, 1] },
+    { "group": "equality", "name": "null on a nested path matches a missing parent too", "documents": "people", "query": { "address.zip": null }, "matches": [1, 3] },
+    { "group": "equality", "name": "strings are compared exactly", "documents": "people", "query": { "id": "ADA" }, "matches": [] },
+    { "group": "equality", "name": "$options i compares strings ignoring case", "documents": "people", "query": { "id": { "$eq": "ADA", "$options": "i" } }, "matches": [0] },
+    { "group": "equality", "name": "ignoring case reaches the strings inside a list", "documents": "people", "query": { "tags": { "$eq": ["MATH", "POETRY"], "$options": "i" } }, "matches": [0] },
+    { "group": "equality", "name": "and the strings inside an object", "documents": "people", "query": { "address": { "$eq": { "city": "LONDON", "zip": "w1" }, "$options": "i" } }, "matches": [0] },
+    { "group": "equality", "name": "but never the keys, which are names rather than values", "documents": "people", "query": { "address": { "$eq": { "CITY": "London", "ZIP": "W1" }, "$options": "i" } }, "matches": [] },
+    { "group": "equality", "name": "$all ignoring case", "documents": "people", "query": { "tags": { "$all": ["MATH"], "$options": "i" } }, "matches": [0, 2] },
+    { "group": "equality", "name": "$in ignoring case, against a whole list", "documents": "people", "query": { "tags": { "$in": [["MATH", "POETRY"]], "$options": "i" } }, "matches": [0] },
+    { "group": "equality", "name": "no coercion between a number and a string", "documents": "mixed", "query": { "$eq": 1 }, "matches": [0, 6] },
+    { "group": "equality", "name": "true is not 1", "documents": "mixed", "query": { "$eq": true }, "matches": [5] },
+    { "group": "equality", "name": "$ne also matches a missing field", "documents": "people", "query": { "nick": { "$ne": "torvalds" } }, "matches": [0, 1, 2] },
+    { "group": "equality", "name": "$ne on an array means no element equals it", "documents": "people", "query": { "tags": { "$ne": "math" } }, "matches": [1, 3] },
+    { "group": "arrays and paths", "name": "an item that is itself an array is seen through", "documents": "lines", "query": { "sku": "pen" }, "matches": [0, 4] },
+    { "group": "arrays and paths", "name": "a position names an element of the item", "documents": "lines", "query": { "0.sku": "pad" }, "matches": [1] },
+    { "group": "arrays and paths", "name": "an empty item reaches nothing", "documents": "lines", "query": { "sku": { "$exists": false } }, "matches": [2, 3] },
+    { "group": "arrays and paths", "name": "an array's own length is not a field", "documents": "lines", "query": { "length": 2 }, "matches": [] },
+    { "group": "arrays and paths", "name": "a path sees through an array of objects", "documents": "people", "query": { "languages.name": "German" }, "matches": [2] },
+    { "group": "arrays and paths", "name": "a numeric segment is a position", "documents": "people", "query": { "languages.1.name": "French" }, "matches": [0] },
+    { "group": "arrays and paths", "name": "a position past the end reaches nothing", "documents": "people", "query": { "tags.5": { "$exists": true } }, "matches": [] },
+    { "group": "arrays and paths", "name": "operators on an array field are tested separately", "documents": "people", "query": { "languages.level": { "$gt": 4, "$lt": 3 } }, "matches": [2] },
+    { "group": "arrays and paths", "name": "$elemMatch needs one element to satisfy all of it", "documents": "people", "query": { "languages": { "$elemMatch": { "name": "English", "level": { "$gte": 5 } } } }, "matches": [0, 1, 2] },
+    { "group": "arrays and paths", "name": "$elemMatch rejects a split match", "documents": "people", "query": { "languages": { "$elemMatch": { "name": "German", "level": 5 } } }, "matches": [] },
+    { "group": "arrays and paths", "name": "$elemMatch on objects in a nested document", "documents": "matrix", "query": { "points": { "$elemMatch": { "x": 3, "y": { "$lt": 2 } } } }, "matches": [2] },
+    { "group": "arrays and paths", "name": "$elemMatch on primitive elements takes a condition", "documents": "people", "query": { "tags": { "$elemMatch": { "$startsWith": "po" } } }, "matches": [0] },
+    { "group": "arrays and paths", "name": "a path fans out through nested arrays", "documents": "matrix", "query": { "points.y": 1 }, "matches": [2, 3] },
+    { "group": "arrays and paths", "name": "an element of a nested array", "documents": "matrix", "query": { "cells": [5] }, "matches": [1] },
+    { "group": "arrays and paths", "name": "$size counts elements", "documents": "people", "query": { "tags": { "$size": 2 } }, "matches": [0, 1, 2] },
+    { "group": "arrays and paths", "name": "$size takes a condition", "documents": "people", "query": { "languages": { "$size": { "$gt": 1 } } }, "matches": [0, 2] },
+    { "group": "arrays and paths", "name": "$size never matches a non-array", "documents": "people", "query": { "name": { "$size": 12 } }, "matches": [] },
+    { "group": "arrays and paths", "name": "$all needs every value present", "documents": "people", "query": { "tags": { "$all": ["crypto", "math"] } }, "matches": [2] },
+    { "group": "arrays and paths", "name": "an empty $all matches nothing", "documents": "people", "query": { "tags": { "$all": [] } }, "matches": [] },
+    { "group": "existence and type", "name": "$exists true", "documents": "people", "query": { "nick": { "$exists": true } }, "matches": [3] },
+    { "group": "existence and type", "name": "$exists false", "documents": "people", "query": { "score": { "$exists": false } }, "matches": [1] },
+    { "group": "existence and type", "name": "a null value exists", "documents": "people", "query": { "address": { "$exists": true } }, "matches": [0, 1, 2, 3] },
+    { "group": "existence and type", "name": "$type", "documents": "mixed", "query": { "$type": "string" }, "matches": [1, 2] },
+    { "group": "existence and type", "name": "$type integer", "documents": "people", "query": { "score": { "$type": "integer" } }, "matches": [2] },
+    { "group": "existence and type", "name": "$type with a list", "documents": "mixed", "query": { "$type": ["null", "boolean"] }, "matches": [4, 5] },
+    { "group": "existence and type", "name": "$type array matches the array itself", "documents": "mixed", "query": { "$type": "array" }, "matches": [6] },
+    { "group": "existence and type", "name": "$type object", "documents": "mixed", "query": { "$type": "object" }, "matches": [7] },
+    { "group": "ordering", "name": "$gt on numbers", "documents": "people", "query": { "age": { "$gt": 50 } }, "matches": [1, 3] },
+    { "group": "ordering", "name": "a range", "documents": "people", "query": { "age": { "$gte": 36, "$lte": 41 } }, "matches": [0, 2] },
+    { "group": "ordering", "name": "strings compare by code unit", "documents": "people", "query": { "id": { "$lt": "b" } }, "matches": [0, 2] },
+    { "group": "ordering", "name": "a number bound never matches a string", "documents": "mixed", "query": { "$gt": 5 }, "matches": [3] },
+    { "group": "ordering", "name": "a string bound never matches a number", "documents": "mixed", "query": { "$gte": "1" }, "matches": [1, 2] },
+    { "group": "ordering", "name": "ordering never matches a missing field", "documents": "people", "query": { "score": { "$lt": 100 } }, "matches": [2, 3] },
+    { "group": "ordering", "name": "a $date bound reads ISO strings as dates", "documents": "people", "query": { "born": { "$lt": { "$date": "1900-01-01" } } }, "matches": [0] },
+    { "group": "ordering", "name": "a $date literal equals the same instant written differently", "documents": "people", "query": { "born": { "$date": "1906-12-09T00:00:00Z" } }, "matches": [1] },
+    { "group": "ordering", "name": "$in", "documents": "people", "query": { "id": { "$in": ["ada", "linus", "nobody"] } }, "matches": [0, 3] },
+    { "group": "ordering", "name": "$in with null also matches missing", "documents": "people", "query": { "nick": { "$in": [null, "x"] } }, "matches": [0, 1, 2] },
+    { "group": "ordering", "name": "$in against an array field", "documents": "people", "query": { "tags": { "$in": ["navy", "crypto"] } }, "matches": [1, 2] },
+    { "group": "ordering", "name": "an empty $in matches nothing", "documents": "people", "query": { "id": { "$in": [] } }, "matches": [] },
+    { "group": "ordering", "name": "$nin also matches missing", "documents": "people", "query": { "score": { "$nin": [99, 7.5] } }, "matches": [0, 1] },
+    { "group": "ordering", "name": "an empty $nin matches everything", "documents": "people", "query": { "id": { "$nin": [] } }, "matches": [0, 1, 2, 3] },
+    { "group": "ordering", "name": "$in ignoring case", "documents": "people", "query": { "id": { "$in": ["ADA", "Alan"], "$options": "i" } }, "matches": [0, 2] },
+    { "group": "ordering", "name": "$mod", "documents": "numbers", "query": { "$mod": [5, 0] }, "matches": [1, 2] },
+    { "group": "strings", "name": "$contains", "documents": "people", "query": { "name": { "$contains": "ur" } }, "matches": [2] },
+    { "group": "strings", "name": "$contains is exact about case by default", "documents": "people", "query": { "name": { "$contains": "ADA" } }, "matches": [] },
+    { "group": "strings", "name": "$contains ignoring case", "documents": "people", "query": { "name": { "$contains": "TOR", "$options": "i" } }, "matches": [3] },
+    { "group": "strings", "name": "$contains with a list means any of them", "documents": "people", "query": { "name": { "$contains": ["Hop", "Tur"] } }, "matches": [1, 2] },
+    { "group": "strings", "name": "$startsWith", "documents": "people", "query": { "address.city": { "$startsWith": "Man" } }, "matches": [2] },
+    { "group": "strings", "name": "$endsWith", "documents": "people", "query": { "name": { "$endsWith": "er" } }, "matches": [1] },
+    { "group": "strings", "name": "string operators look into arrays", "documents": "people", "query": { "tags": { "$startsWith": "cr" } }, "matches": [2] },
+    { "group": "strings", "name": "string operators never match a non-string", "documents": "mixed", "query": { "$contains": "1" }, "matches": [1, 2] },
+    { "group": "strings", "name": "$word matches a whole component", "documents": "hosts", "query": { "actor": { "$word": "1.2.3.4" } }, "matches": [0] },
+    { "group": "strings", "name": "$word finds a network by its prefix", "documents": "hosts", "query": { "actor": { "$word": "1.2.3" } }, "matches": [0, 1, 3] },
+    { "group": "strings", "name": "$word finds an address by its tail", "documents": "hosts", "query": { "actor": { "$word": "3.45" } }, "matches": [1] },
+    { "group": "strings", "name": "a value ending in a separator chooses its own boundary", "documents": "hosts", "query": { "actor": { "$word": "203.0.113." } }, "matches": [4] },
+    { "group": "strings", "name": "$regex", "documents": "people", "query": { "name": { "$regex": "^A\\w+ [LT]" } }, "matches": [0, 2] },
+    { "group": "strings", "name": "$regex with the i flag", "documents": "people", "query": { "nick": { "$regex": "^TOR", "$options": "i" } }, "matches": [3] },
+    { "group": "logic", "name": "$or", "documents": "people", "query": { "$or": [{ "id": "ada" }, { "age": { "$gt": 80 } }] }, "matches": [0, 1] },
+    { "group": "logic", "name": "$and", "documents": "people", "query": { "$and": [{ "tags": "math" }, { "tags": "crypto" }] }, "matches": [2] },
+    { "group": "logic", "name": "$nor", "documents": "people", "query": { "$nor": [{ "active": false }, { "tags": "poetry" }] }, "matches": [2, 3] },
+    { "group": "logic", "name": "$not at the top negates a whole query", "documents": "people", "query": { "$not": { "tags": "math" } }, "matches": [1, 3] },
+    { "group": "logic", "name": "$not on a field negates a condition, and matches missing", "documents": "people", "query": { "score": { "$not": { "$gt": 50 } } }, "matches": [0, 1, 3] },
+    { "group": "logic", "name": "an empty $and matches everything", "documents": "people", "query": { "$and": [] }, "matches": [0, 1, 2, 3] },
+    { "group": "logic", "name": "an empty $or matches nothing", "documents": "people", "query": { "$or": [] }, "matches": [] },
+    { "group": "logic", "name": "an empty $nor matches everything", "documents": "people", "query": { "$nor": [] }, "matches": [0, 1, 2, 3] },
+    { "group": "logic", "name": "$comment is ignored", "documents": "people", "query": { "$comment": "why this exists", "id": "alan" }, "matches": [2] },
+    { "group": "logic", "name": "a condition at the top tests the item itself", "documents": "numbers", "query": { "$gt": 1, "$lt": 10 }, "matches": [1, 4] },
+    { "group": "logic", "name": "$not at the top on primitives", "documents": "numbers", "query": { "$not": { "$gte": 5 } }, "matches": [0, 3, 4] },
+    { "group": "text", "name": "$text finds a phrase anywhere, ignoring case", "documents": "people", "query": { "$text": "new york" }, "matches": [1] },
+    { "group": "text", "name": "$text looks inside arrays and nested objects", "documents": "people", "query": { "$text": "german" }, "matches": [2] },
+    { "group": "text", "name": "$text searches numbers when the phrase has a digit", "documents": "people", "query": { "$text": "85" }, "matches": [1] },
+    { "group": "text", "name": "$text never reads a key as text", "documents": "people", "query": { "$text": "languages" }, "matches": [] },
+    { "group": "text", "name": "$text in named fields only", "documents": "people", "query": { "$text": { "$search": "tor", "$fields": ["nick"] } }, "matches": [3] },
+    { "group": "text", "name": "$text case-sensitive", "documents": "people", "query": { "$text": { "$search": "Tor", "$caseSensitive": true } }, "matches": [3] },
+    { "group": "text", "name": "an empty $text matches everything", "documents": "people", "query": { "$text": "" }, "matches": [0, 1, 2, 3] },
+    { "group": "references", "name": "one field greater than another", "documents": "pairs", "query": { "out": { "$gt": { "$field": "in" } } }, "matches": [0, 5] },
+    { "group": "references", "name": "one field equal to another, written as a value", "documents": "pairs", "query": { "out": { "$field": "in" } }, "matches": [2] },
+    { "group": "references", "name": "$ne against a reference holds when no pair is equal", "documents": "pairs", "query": { "out": { "$ne": { "$field": "in" } } }, "matches": [0, 1, 3, 4, 5] },
+    { "group": "references", "name": "ordering against a reference", "documents": "pairs", "query": { "out": { "$lte": { "$field": "in" } } }, "matches": [1, 2, 5] },
+    { "group": "references", "name": "a reference that reaches nothing matches nothing", "documents": "pairs", "query": { "out": { "$gt": { "$field": "missing" } } }, "matches": [] },
+    { "group": "references", "name": "a reference coerces nothing either", "documents": "pairs", "query": { "out": { "$eq": { "$field": "in" }, "$lt": 6 } }, "matches": [] },
+    { "group": "references", "name": "a reference reaching an array holds for any of its values", "documents": "pairs", "query": { "out": { "$lt": { "$field": "in" } } }, "matches": [1, 5] },
+    { "group": "length", "name": "$length counts an array's elements", "documents": "people", "query": { "tags": { "$length": 2 } }, "matches": [0, 1, 2] },
+    { "group": "length", "name": "$length counts a string's UTF-16 code units", "documents": "people", "query": { "name": { "$length": 12 } }, "matches": [0, 1] },
+    { "group": "length", "name": "$length takes a condition", "documents": "people", "query": { "name": { "$length": { "$gt": 12 } } }, "matches": [3] },
+    { "group": "length", "name": "a character outside the basic plane is two code units", "documents": "texts", "query": { "s": { "$length": 2 } }, "matches": [2] },
+    { "group": "length", "name": "$length never matches something without one", "documents": "people", "query": { "age": { "$length": 2 } }, "matches": [] },
+    { "group": "glob", "name": "* stands for any run", "documents": "people", "query": { "name": { "$glob": "A*" } }, "matches": [0, 2] },
+    { "group": "glob", "name": "a glob matches the whole value", "documents": "people", "query": { "id": { "$glob": "ad" } }, "matches": [] },
+    { "group": "glob", "name": "? stands for one character", "documents": "people", "query": { "id": { "$glob": "a?a" } }, "matches": [0] },
+    { "group": "glob", "name": "a list means any of them", "documents": "people", "query": { "id": { "$glob": ["ada", "gr*"] } }, "matches": [0, 1] },
+    { "group": "glob", "name": "a glob ignoring case", "documents": "people", "query": { "id": { "$glob": "A*", "$options": "i" } }, "matches": [0, 2] },
+    { "group": "glob", "name": "a backslash escapes a star", "documents": "texts", "query": { "s": { "$glob": "a\\*b" } }, "matches": [3] },
+    { "group": "glob", "name": "an unescaped star still stands for any run", "documents": "texts", "query": { "s": { "$glob": "a*b" } }, "matches": [3] },
+    { "group": "ordering", "name": "a date in a document is ISO 8601, and nothing else a parser might take", "documents": "stamps", "query": { "t": { "$gt": { "$date": "2020-01-01" } } }, "matches": [0, 1, 2, 5] },
+    { "group": "ordering", "name": "a timestamp with no offset is UTC, not the reader's local time", "documents": "stamps", "query": { "t": { "$gte": { "$date": "2020-12-31T10:00:00Z" } } }, "matches": [1, 2] },
+    { "group": "ordering", "name": "and so is a bound written without one", "documents": "stamps", "query": { "t": { "$eq": { "$date": "2020-12-31T10:00:00" } } }, "matches": [1, 2] },
+    { "group": "ordering", "name": "neither side carrying an offset still means one instant", "documents": "stamps", "query": { "t": { "$lt": { "$date": "2020-12-31 10:00:01" } } }, "matches": [0, 1, 2, 5] },
+    { "group": "strings", "name": "$word counts a character, not half of one", "documents": "letters", "query": { "s": { "$word": "𝐀" } }, "matches": [1] },
+    { "group": "strings", "name": "and the same for an ordinary letter", "documents": "letters", "query": { "s": { "$word": "a" } }, "matches": [3] },
+    { "group": "relative dates", "name": "within the last hour", "documents": "events", "now": "2026-09-22T12:00:00Z", "query": { "at": { "$gte": { "$date": { "$ago": "1h" } } } }, "matches": [0] },
+    { "group": "relative dates", "name": "within the last day", "documents": "events", "now": "2026-09-22T12:00:00Z", "query": { "at": { "$gte": { "$date": { "$ago": "1d" } } } }, "matches": [0, 1] },
+    { "group": "relative dates", "name": "a compound duration", "documents": "events", "now": "2026-09-22T12:00:00Z", "query": { "at": { "$gte": { "$date": { "$ago": "1h30m" } } } }, "matches": [0] },
+    { "group": "relative dates", "name": "now itself", "documents": "events", "now": "2026-09-22T12:00:00Z", "query": { "at": { "$lt": { "$date": "now" } } }, "matches": [0, 1, 2] },
+    { "group": "relative dates", "name": "ahead of now", "documents": "events", "now": "2026-09-22T12:00:00Z", "query": { "at": { "$gt": { "$date": { "$ahead": "1h" } } } }, "matches": [] },
+    { "group": "refusals", "name": "a reference where a value belongs", "query": { "a": { "$in": [{ "$field": "b" }] } }, "error": true, "at": "a.$in[0]" },
+    { "group": "refusals", "name": "a reference whose path is not a string", "query": { "a": { "$gt": { "$field": 5 } } }, "error": true, "at": "a.$gt" },
+    { "group": "refusals", "name": "a negative $length", "query": { "a": { "$length": -1 } }, "error": true, "at": "a.$length" },
+    { "group": "refusals", "name": "a glob that is not a string", "query": { "a": { "$glob": 5 } }, "error": true, "at": "a.$glob" },
+    { "group": "refusals", "name": "a duration with no unit anybody fixed", "query": { "a": { "$gt": { "$date": { "$ago": "1fortnight" } } } }, "error": true, "at": "a.$gt" },
+    { "group": "refusals", "name": "a relative date that is not a duration", "query": { "a": { "$gt": { "$date": { "$ago": 5 } } } }, "error": true, "at": "a.$gt" },
+    { "group": "refusals", "name": "an unknown operator", "query": { "age": { "$gtt": 5 } }, "error": true, "at": "age.$gtt" },
+    { "group": "refusals", "name": "an unknown top-level operator", "query": { "$where": "1" }, "error": true, "at": "$where" },
+    { "group": "refusals", "name": "a query operator inside a condition", "query": { "age": { "$or": [] } }, "error": true, "at": "age.$or" },
+    { "group": "refusals", "name": "operators mixed with field names", "query": { "address": { "$exists": true, "city": "London" } }, "error": true, "at": "address" },
+    { "group": "refusals", "name": "a query that is not an object", "query": ["id", "ada"], "error": true, "at": "" },
+    { "group": "refusals", "name": "$or that is not a list", "query": { "$or": { "id": "ada" } }, "error": true, "at": "$or" },
+    { "group": "refusals", "name": "$in that is not a list", "query": { "id": { "$in": "ada" } }, "error": true, "at": "id.$in" },
+    { "group": "refusals", "name": "an ordering bound that is not comparable", "query": { "age": { "$gt": true } }, "error": true, "at": "age.$gt" },
+    { "group": "refusals", "name": "a $date that is not a date", "query": { "born": { "$gt": { "$date": "yesterday-ish" } } }, "error": true, "at": "born.$gt" },
+    { "group": "refusals", "name": "a pattern that does not compile", "query": { "name": { "$regex": "(" } }, "error": true, "at": "name.$regex" },
+    { "group": "refusals", "name": "a stateful regex flag", "query": { "name": { "$regex": "a", "$options": "g" } }, "error": true, "at": "name.$options" },
+    { "group": "refusals", "name": "$options with nothing to apply to", "query": { "age": { "$gt": 1, "$options": "i" } }, "error": true, "at": "age.$options" },
+    { "group": "refusals", "name": "an unknown type name", "query": { "age": { "$type": "float" } }, "error": true, "at": "age.$type[0]" },
+    { "group": "refusals", "name": "$exists that is not a boolean", "query": { "age": { "$exists": 1 } }, "error": true, "at": "age.$exists" },
+    { "group": "refusals", "name": "a $mod divisor of zero", "query": { "age": { "$mod": [0, 1] } }, "error": true, "at": "age.$mod" },
+    { "group": "refusals", "name": "a negative $size", "query": { "tags": { "$size": -1 } }, "error": true, "at": "tags.$size" },
+    { "group": "refusals", "name": "$not holding a value rather than a condition", "query": { "age": { "$not": 5 } }, "error": true, "at": "age.$not" },
+    { "group": "refusals", "name": "an empty path segment", "query": { "address..city": "London" }, "error": true, "at": "address..city" },
+    { "group": "refusals", "name": "an unknown part of a text search", "query": { "$text": { "$search": "a", "$language": "en" } }, "error": true, "at": "$text.$language" },
+    { "group": "refusals", "name": "$fields that is not a list, beside an empty phrase", "query": { "$text": { "$search": "", "$fields": 42 } }, "error": true, "at": "$text.$fields" },
+    { "group": "refusals", "name": "an empty $fields, beside an empty phrase", "query": { "$text": { "$search": "", "$fields": [] } }, "error": true, "at": "$text.$fields" }
+  ]
+}

package/dist/array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Adds the methods.
+ *
+ * Safe to call more than once, and safe when another copy of JQL has already installed
+ * them: whichever copy got there first keeps the field. Throws only for a method of the
+ * same name that is not JQL's at all, because installing over that would silently change
+ * what its callers run.
+ */
+export declare function install(): void;
+/** Removes JQL's methods — this copy's, and any another copy of it installed. */
+export declare function uninstall(): void;

package/dist/async.d.ts

@@ -0,0 +1,44 @@
+import { type CompileOptions } from "./core.js";
+import type { FieldName, QueryLike, Request, Source } from "./types.js";
+/**
+ * The same questions, asked of something that arrives over time.
+ *
+ * A log file read line by line, a cursor over a store, a stream of events: the items are
+ * the same shape, and the query that filters an array should filter these. Everything here
+ * is the ordinary engine with an `await` in the loop — the query is compiled once, before
+ * the first item, and the helpers stop reading as soon as the answer cannot change.
+ *
+ * That last property is the point of `filterStream` and of a limit: a source that never
+ * ends still answers "the first twenty matches", because nothing pulls from it afterwards.
+ * Sorting is the exception and says so — an order over items you have not seen yet is not
+ * an order — so `searchAsync` with a sort reads the whole source, keeping only the page it
+ * was asked for.
+ */
+/** Anything that yields items, now or later. */
+export type AsyncSource<T> = AsyncIterable<T> | Source<T> | ReadonlyMap<unknown, T>;
+/** Every matching item, as they arrive. The caller can stop at any point, and the source stops with it. */
+export declare function filterStream<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): AsyncGenerator<T>;
+/** The first match, or `undefined`. Stops reading at it. */
+export declare function findAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T | undefined>;
+/** Every match, as an array. Reads the whole source, so give an endless one a limit through `searchAsync`. */
+export declare function filterAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T[]>;
+/** How many match. */
+export declare function countAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<number>;
+/** Whether any item matches. Stops at the first. */
+export declare function someAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<boolean>;
+/** Whether every item matches. True for an empty source. Stops at the first that does not. */
+export declare function everyAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<boolean>;
+/**
+ * A whole request over a source that arrives over time.
+ *
+ * Without a sort it stops as soon as the page is full, so an endless source still answers.
+ * With a sort it reads everything — it has to — but holds only `skip + limit` items while
+ * it does, the same bounded heap the synchronous version uses.
+ */
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request: Request<T, NoInfer<Extra>> & {
+    readonly fields: readonly FieldName<T, NoInfer<Extra>>[];
+}, options?: CompileOptions<Extra>): Promise<Record<string, unknown>[]>;
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request: Request<T, NoInfer<Extra>> & {
+    readonly omit: readonly FieldName<T, NoInfer<Extra>>[];
+}, options?: CompileOptions<Extra>): Promise<Partial<T>[]>;
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T[]>;

package/dist/canonical.d.ts

@@ -0,0 +1,18 @@
+import { type CompileOptions } from "./core.js";
+import type { QueryLike, UntypedQuery } from "./types.js";
+/**
+ * The canonical form of a query.
+ *
+ * Refuses anything that is not a valid query, because a canonical form of nonsense would
+ * be nonsense somebody had stored deliberately.
+ */
+export declare function canonical<T, Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): UntypedQuery;
+/**
+ * A short, stable name for a query's canonical form.
+ *
+ * For cache keys, for telling two saved filters apart, and for noticing that the filter
+ * somebody is saving is one they already have. Not a cryptographic hash: it is a
+ * 64-bit checksum written as hex, so two different queries can collide — rarely, and never
+ * in a way that matters for a cache you can miss.
+ */
+export declare function fingerprint<T, Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): string;

package/dist/cjs/array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Adds the methods.
+ *
+ * Safe to call more than once, and safe when another copy of JQL has already installed
+ * them: whichever copy got there first keeps the field. Throws only for a method of the
+ * same name that is not JQL's at all, because installing over that would silently change
+ * what its callers run.
+ */
+export declare function install(): void;
+/** Removes JQL's methods — this copy's, and any another copy of it installed. */
+export declare function uninstall(): void;

package/dist/cjs/async.d.ts

@@ -0,0 +1,44 @@
+import { type CompileOptions } from "./core.js";
+import type { FieldName, QueryLike, Request, Source } from "./types.js";
+/**
+ * The same questions, asked of something that arrives over time.
+ *
+ * A log file read line by line, a cursor over a store, a stream of events: the items are
+ * the same shape, and the query that filters an array should filter these. Everything here
+ * is the ordinary engine with an `await` in the loop — the query is compiled once, before
+ * the first item, and the helpers stop reading as soon as the answer cannot change.
+ *
+ * That last property is the point of `filterStream` and of a limit: a source that never
+ * ends still answers "the first twenty matches", because nothing pulls from it afterwards.
+ * Sorting is the exception and says so — an order over items you have not seen yet is not
+ * an order — so `searchAsync` with a sort reads the whole source, keeping only the page it
+ * was asked for.
+ */
+/** Anything that yields items, now or later. */
+export type AsyncSource<T> = AsyncIterable<T> | Source<T> | ReadonlyMap<unknown, T>;
+/** Every matching item, as they arrive. The caller can stop at any point, and the source stops with it. */
+export declare function filterStream<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): AsyncGenerator<T>;
+/** The first match, or `undefined`. Stops reading at it. */
+export declare function findAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T | undefined>;
+/** Every match, as an array. Reads the whole source, so give an endless one a limit through `searchAsync`. */
+export declare function filterAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T[]>;
+/** How many match. */
+export declare function countAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<number>;
+/** Whether any item matches. Stops at the first. */
+export declare function someAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<boolean>;
+/** Whether every item matches. True for an empty source. Stops at the first that does not. */
+export declare function everyAsync<T, Extra extends object = {}>(source: AsyncSource<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<boolean>;
+/**
+ * A whole request over a source that arrives over time.
+ *
+ * Without a sort it stops as soon as the page is full, so an endless source still answers.
+ * With a sort it reads everything — it has to — but holds only `skip + limit` items while
+ * it does, the same bounded heap the synchronous version uses.
+ */
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request: Request<T, NoInfer<Extra>> & {
+    readonly fields: readonly FieldName<T, NoInfer<Extra>>[];
+}, options?: CompileOptions<Extra>): Promise<Record<string, unknown>[]>;
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request: Request<T, NoInfer<Extra>> & {
+    readonly omit: readonly FieldName<T, NoInfer<Extra>>[];
+}, options?: CompileOptions<Extra>): Promise<Partial<T>[]>;
+export declare function searchAsync<T, Extra extends object = {}>(source: AsyncSource<T>, request?: Request<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): Promise<T[]>;

package/dist/cjs/canonical.d.ts

@@ -0,0 +1,18 @@
+import { type CompileOptions } from "./core.js";
+import type { QueryLike, UntypedQuery } from "./types.js";
+/**
+ * The canonical form of a query.
+ *
+ * Refuses anything that is not a valid query, because a canonical form of nonsense would
+ * be nonsense somebody had stored deliberately.
+ */
+export declare function canonical<T, Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): UntypedQuery;
+/**
+ * A short, stable name for a query's canonical form.
+ *
+ * For cache keys, for telling two saved filters apart, and for noticing that the filter
+ * somebody is saving is one they already have. Not a cryptographic hash: it is a
+ * 64-bit checksum written as hex, so two different queries can collide — rarely, and never
+ * in a way that matters for a cache you can miss.
+ */
+export declare function fingerprint<T, Extra extends object = {}>(query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): string;

package/dist/cjs/cli.d.ts

@@ -0,0 +1,15 @@
+export interface Streams {
+    readonly out: (text: string) => void;
+    readonly err: (text: string) => void;
+    /** Where a `-` argument, or no file at all, reads from. */
+    readonly stdin: () => AsyncIterable<string>;
+}
+/** Runs the command. Returns the exit code rather than calling `process.exit`, so it can be tested in-process. */
+export declare function main(argv: readonly string[], io: Streams): Promise<number>;
+/**
+ * The command as a process: reads stdin, writes the streams, sets the exit code.
+ *
+ * Kept apart from `main` so the tests can call `main` with writers of their own and assert
+ * which stream each line went to — part of the contract, not an implementation detail.
+ */
+export declare function run(argv?: readonly string[]): Promise<void>;

package/dist/cjs/collections.d.ts

@@ -0,0 +1,34 @@
+import { type CompileOptions } from "./core.js";
+import type { QueryLike, Source } from "./types.js";
+/** The first item that matches, or `undefined`. Stops at the first match. */
+export declare function find<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V | undefined;
+export declare function find<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T | undefined;
+/** The position of the first item that matches, or -1. For a `Map`, the position in insertion order. */
+export declare function findIndex<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;
+export declare function findIndex<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;
+/** Every item that matches, in order, as a new array. */
+export declare function filter<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): V[];
+export declare function filter<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): T[];
+/** How many items match. Counts in place rather than building the list it would count. */
+export declare function count<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;
+export declare function count<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): number;
+/** Whether any item matches. Stops at the first. */
+export declare function some<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;
+export declare function some<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;
+/** Whether every item matches. True for an empty collection. Stops at the first that does not. */
+export declare function every<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;
+export declare function every<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): boolean;
+/** The matches and the rest, in one pass. */
+export declare function partition<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [V[], V[]];
+export declare function partition<T, Extra extends object = {}>(source: Source<T>, query: QueryLike<T, NoInfer<Extra>>, options?: CompileOptions<Extra>): [T[], T[]];
+/** The entries of a `Map` whose value matches, as a new `Map` with the same keys. */
+export declare function filterMap<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): Map<K, V>;
+/**
+ * The properties of a plain object whose value matches, as a new object.
+ *
+ * Own enumerable properties only — the same ones `Object.entries` sees.
+ */
+export declare function filterRecord<V, Extra extends object = {}>(source: Readonly<Record<string, V>>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): Record<string, V>;
+/** The first value of a plain object that matches, with its key. */
+export declare function findEntry<V, Extra extends object = {}>(source: Readonly<Record<string, V>>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [string, V] | undefined;
+export declare function findEntry<K, V, Extra extends object = {}>(source: ReadonlyMap<K, V>, query: QueryLike<V, NoInfer<Extra>>, options?: CompileOptions<Extra>): [K, V] | undefined;