@thi.ng/oquery 2.2.9 → 2.2.10

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -79,7 +79,7 @@ For Node.js REPL:
 const oquery = await import("@thi.ng/oquery");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.66 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.67 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/match.js

@@ -1,169 +1,79 @@
 import { isNumber } from "@thi.ng/checks/is-number";
 import { isString } from "@thi.ng/checks/is-string";
 import { numericOp, stringOp } from "@thi.ng/compare";
-/**
- * Syntax sugar for {@link matchMultiple} using string arrays. Matches set of
- * given strings against an item's chosen field of strings and by default only
- * succeeds if all provided strings can be matched.
- *
- * @remarks
- * Any provided string prefixed with `!` is treated as an exclusion and any item
- * which contains any of these exclusions is automatically rejected, even if
- * other strings could be matched.
- *
- * See {@link matchMultiple} for more details & code example.
- *
- * @param key
- * @param matches
- * @param opts
- * @returns
- */
-export const matchStrings = (key, matches, opts) => {
-    const [includes, excludes] = matches.reduce((acc, x) => {
-        x[0] === "!" ? acc[1].push(x.substring(1)) : acc[0].push(x);
-        return acc;
-    }, [[], []]);
-    return matchMultiple(key, includes, excludes, opts);
+const matchStrings = (key, matches, opts) => {
+  const [includes, excludes] = matches.reduce(
+    (acc, x) => {
+      x[0] === "!" ? acc[1].push(x.substring(1)) : acc[0].push(x);
+      return acc;
+    },
+    [[], []]
+  );
+  return matchMultiple(key, includes, excludes, opts);
 };
-/**
- * Returns a {@link QueryTerm} for use with {@link query} to perform set-like
- * intersection or union queries with optional negation/exclusions. Matches set
- * of given values against an item's chosen field of values and by default only
- * succeeds if all provided `includes` can be matched (aka intersection query)
- * and there're no values from `excludes` present.
- *
- * @remarks
- * If the `union` option is true, only one of the provided values needs to
- * match. Exclusions _always_ take precedence.
- *
- * Note: See {@link matchStrings} for a syntax sugar of this function, aimed at
- * matching `string[]` options.
- *
- * @example
- * ```ts
- * const DB = [
- *   { id: 1, tags: ["a", "b"] },
- *   { id: 2, tags: ["c", "b"] },
- *   { id: 3, tags: ["c", "a"] },
- * ];
- *
- * // tag intersection
- * query(DB, [matchStrings("tags", ["a", "b"])])
- * // [ { id: 1, tags: ["a", "b"] } ]
- *
- * // tag union
- * query(DB, [matchStrings("tags", ["a", "b"])])
- * // here returns full DB...
- * // since each item either has `a` and/or `b` tags
- *
- * // tag exclusion (require `a`, disallow `b`)
- * query(DB, [matchStrings("tags", ["a", "!b"])])
- * // [ { id: 3, tags: ["c", "a"] } ]
- * ```
- *
- * @param key
- * @param matches
- * @param opts
- */
-export const matchMultiple = (key, includes, excludes, opts) => {
-    const { union, value: valueFn } = { union: false, ...opts };
-    return excludes.length
-        ? {
-            q: [
-                key,
-                (values) => {
-                    const $values = valueFn ? valueFn(values) : values;
-                    for (let x of excludes) {
-                        if ($values.includes(x))
-                            return false;
-                    }
-                    let match = false;
-                    for (let x of includes) {
-                        if ($values.includes(x)) {
-                            match = true;
-                            if (union)
-                                break;
-                        }
-                        else if (!union) {
-                            match = false;
-                            break;
-                        }
-                    }
-                    return match;
-                },
-            ],
-            opts: { cwise: false },
+const matchMultiple = (key, includes, excludes, opts) => {
+  const { union, value: valueFn } = { union: false, ...opts };
+  return excludes.length ? {
+    q: [
+      key,
+      (values) => {
+        const $values = valueFn ? valueFn(values) : values;
+        for (let x of excludes) {
+          if ($values.includes(x))
+            return false;
         }
-        : { q: [key, includes], opts: { intersect: !union } };
-};
-/**
- * Returns a {@link QueryTerm} to match a key's value against a regexp or string
- * expression.
- *
- * @remarks
- * If `expr` is a regexp it will be used as is, but if given a string the
- * following rules apply:
- *
- * - if `expr` is the sole `*` it will match any non-null value
- * - if `expr` starts with `=`, `!=`, `<`, `<=`, `>=` or `>`, values will be
- *   matched using comparators. If the following chars in `expr` are numeric,
- *   the comparisons will be done as numbers otherwise as strings. Whitespace
- *   between operator and value are ignored.
- *
- * @example
- * ```ts
- * const DB = [
- *   { id: "aaa", score: 32 },
- *   { id: "bbbb", score: 60 },
- *   { id: "c", score: 15 },
- * ];
- *
- * query(DB, [matchPattern("id", /[a-z]{4,}/)]);
- * // [{ id: "bbbb", score: 60 }]
- * query(DB, [matchPattern("id", ">= c")]);
- * // [{ id: "c", score: 15 }]
- *
- * query(DB, [matchPattern("score", "<50")]);
- * // [{ id: "a", score: 32 }, { id: "c", score: 15 }]
- * ```
- *
- * @param key
- * @param expr
- * @param opts
- */
-export const matchPattern = (key, expr, opts) => {
-    let re;
-    if (expr instanceof RegExp) {
-        re = expr;
-    }
-    else {
-        if (expr === "*")
-            return { q: [key, (x) => x != null], opts };
-        if (/^[<>=!]/.test(expr)) {
-            const op = /^[<>=!]+/.exec(expr)[0];
-            const arg = expr.substring(op.length).trim();
-            const argN = parseFloat(arg);
-            return matchCompare(key, op, isNaN(argN) ? arg : argN, opts);
+        let match = false;
+        for (let x of includes) {
+          if ($values.includes(x)) {
+            match = true;
+            if (union)
+              break;
+          } else if (!union) {
+            match = false;
+            break;
+          }
         }
-        re = new RegExp(expr, "i");
+        return match;
+      }
+    ],
+    opts: { cwise: false }
+  } : { q: [key, includes], opts: { intersect: !union } };
+};
+const matchPattern = (key, expr, opts) => {
+  let re;
+  if (expr instanceof RegExp) {
+    re = expr;
+  } else {
+    if (expr === "*")
+      return { q: [key, (x) => x != null], opts };
+    if (/^[<>=!]/.test(expr)) {
+      const op = /^[<>=!]+/.exec(expr)[0];
+      const arg = expr.substring(op.length).trim();
+      const argN = parseFloat(arg);
+      return matchCompare(
+        key,
+        op,
+        isNaN(argN) ? arg : argN,
+        opts
+      );
     }
-    return {
-        q: [
-            key,
-            (x) => (isString(x) || isNumber(x)) && re.test(String(x)),
-        ],
-        opts,
-    };
+    re = new RegExp(expr, "i");
+  }
+  return {
+    q: [
+      key,
+      (x) => (isString(x) || isNumber(x)) && re.test(String(x))
+    ],
+    opts
+  };
 };
-/**
- * Same as the comparison expression case of {@link matchPattern}, only
- * accepting different args.
- *
- * @param key
- * @param match
- * @param opts
- */
-export const matchCompare = (key, op, arg, opts) => ({
-    q: [key, isNumber(arg) ? numericOp(op, arg) : stringOp(op, arg)],
-    opts,
+const matchCompare = (key, op, arg, opts) => ({
+  q: [key, isNumber(arg) ? numericOp(op, arg) : stringOp(op, arg)],
+  opts
 });
+export {
+  matchCompare,
+  matchMultiple,
+  matchPattern,
+  matchStrings
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/oquery",
-  "version": "2.2.9",
+  "version": "2.2.10",
   "description": "Datalog-inspired, optimized pattern/predicate query engine for JS objects & arrays of objects",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,14 +35,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/compare": "^2.2.7",
-    "@thi.ng/defmulti": "^3.0.9",
-    "@thi.ng/equiv": "^2.1.36"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/compare": "^2.2.8",
+    "@thi.ng/defmulti": "^3.0.10",
+    "@thi.ng/equiv": "^2.1.37"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -93,5 +96,5 @@
     ],
     "year": 2020
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/query.js

@@ -6,428 +6,336 @@ import { compareByKey } from "@thi.ng/compare/keys";
 import { reverse } from "@thi.ng/compare/reverse";
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { equiv } from "@thi.ng/equiv";
-/**
- * Classifies a single S,P,O term. See {@link QueryType} for explanations.
- *
- * @param x -
- *
- * @internal
- */
-const classify = (x) => (x != null ? (isFunction(x) ? "f" : "l") : "n");
-/** @internal */
-const ensureArray = (src) => (isArray(src) ? src : [...src]);
-/** @internal */
+const classify = (x) => x != null ? isFunction(x) ? "f" : "l" : "n";
+const ensureArray = (src) => isArray(src) ? src : [...src];
 const ensureSet = (src) => isArray(src) ? new Set(src) : src;
-/**
- * HOF predicate function for intersection queries (i.e. iff `opts.intersect =
- * true`). Takes an array or set query term and returns predicate to check if
- * ALL of the query term elements are present in a given object (assumed to be
- * an array or set too).
- *
- * @param src -
- *
- * @internal
- */
 const intersect = (src) => {
-    const a = ensureArray(src);
-    const num = a.length;
-    return (b) => {
-        const $b = ensureSet(b);
-        for (let i = num; i-- > 0;) {
-            if (!$b.has(a[i]))
-                return false;
-        }
-        return true;
-    };
+  const a = ensureArray(src);
+  const num = a.length;
+  return (b) => {
+    const $b = ensureSet(b);
+    for (let i = num; i-- > 0; ) {
+      if (!$b.has(a[i]))
+        return false;
+    }
+    return true;
+  };
 };
-/**
- * Checks the type of a single S,P,O term and if an array or Set, returns a
- * predicate function to check if an element is included. Otherwise, returns
- * input. If `isec` is true, the returned predicate will be the result of
- * {@link intersect}.
- *
- * @param x -
- * @param isec -
- *
- * @internal
- */
-const coerce = (x, isec = false) => isArray(x)
-    ? isec
-        ? intersect(x)
-        : (y) => x.includes(y)
-    : isSet(x)
-        ? isec
-            ? intersect(x)
-            : (y) => x.has(y)
-        : x;
-/**
- * Similar to {@link coerce}, but intended for S,P terms. Unless `x` is a
- * function or null, coerces `x` (or its elements) to strings first.
- *
- * @param x -
- *
- * @internal
- */
-const coerceStr = (x) => isArray(x)
-    ? coerce(x.map((y) => String(y)))
-    : isSet(x)
-        ? coerce(new Set([...x].map((y) => String(y))))
-        : x == null || isFunction(x)
-            ? x
-            : String(x);
+const coerce = (x, isec = false) => isArray(x) ? isec ? intersect(x) : (y) => x.includes(y) : isSet(x) ? isec ? intersect(x) : (y) => x.has(y) : x;
+const coerceStr = (x) => isArray(x) ? coerce(x.map((y) => String(y))) : isSet(x) ? coerce(new Set([...x].map((y) => String(y)))) : x == null || isFunction(x) ? x : String(x);
 const addTriple = (acc, s, p, o) => {
-    const sval = acc[s];
-    sval ? (sval[p] = o) : (acc[s] = { [p]: o });
+  const sval = acc[s];
+  sval ? sval[p] = o : acc[s] = { [p]: o };
 };
 const match = (o, val, opts) => {
-    if (val != null) {
-        const pred = ((isFunction(o) ? o : ($) => opts.equiv(o, $)));
-        return opts.cwise && isArray(val) ? val.some(pred) : pred(val);
-    }
-    return false;
+  if (val != null) {
+    const pred = isFunction(o) ? o : ($) => opts.equiv(o, $);
+    return opts.cwise && isArray(val) ? val.some(pred) : pred(val);
+  }
+  return false;
 };
 const collect = (acc, s, p, o, val, opts) => {
-    if (val != null) {
-        const pred = isFunction(o) ? o : ($) => opts.equiv(o, $);
-        if (opts.cwise && isArray(val)) {
-            val = val.filter(pred);
-            val.length && addTriple(acc, s, p, val);
-        }
-        else if (pred(val)) {
-            addTriple(acc, s, p, val);
-        }
+  if (val != null) {
+    const pred = isFunction(o) ? o : ($) => opts.equiv(o, $);
+    if (opts.cwise && isArray(val)) {
+      val = val.filter(pred);
+      val.length && addTriple(acc, s, p, val);
+    } else if (pred(val)) {
+      addTriple(acc, s, p, val);
     }
+  }
 };
-const collectFull = (res, s, val) => (res[s] = val);
+const collectFull = (res, s, val) => res[s] = val;
 const collectSP = (res, sval, s, p, o, opts) => {
-    if (opts.partial) {
-        for (let $p in sval) {
-            p($p) && collect(res, s, $p, o, sval[$p], opts);
-        }
+  if (opts.partial) {
+    for (let $p in sval) {
+      p($p) && collect(res, s, $p, o, sval[$p], opts);
     }
-    else {
-        for (let $p in sval) {
-            if (p($p) && match(o, sval[$p], opts)) {
-                collectFull(res, s, sval);
-                return;
-            }
-        }
+  } else {
+    for (let $p in sval) {
+      if (p($p) && match(o, sval[$p], opts)) {
+        collectFull(res, s, sval);
+        return;
+      }
     }
+  }
 };
 const collectSO = (res, sval, s, o, opts) => {
-    if (opts.partial) {
-        for (let p in sval) {
-            collect(res, s, p, o, sval[p], opts);
-        }
+  if (opts.partial) {
+    for (let p in sval) {
+      collect(res, s, p, o, sval[p], opts);
     }
-    else {
-        for (let p in sval) {
-            if (match(o, sval[p], opts)) {
-                collectFull(res, s, sval);
-                return;
-            }
-        }
+  } else {
+    for (let p in sval) {
+      if (match(o, sval[p], opts)) {
+        collectFull(res, s, sval);
+        return;
+      }
     }
+  }
 };
 const queryLL = (res, db, s, p, o, opts) => {
-    const sval = db[s];
-    const val = sval?.[p];
-    if (opts.partial) {
-        collect(res, s, p, o, val, opts);
-    }
-    else {
-        match(o, val, opts) && collectFull(res, s, sval);
-    }
+  const sval = db[s];
+  const val = sval?.[p];
+  if (opts.partial) {
+    collect(res, s, p, o, val, opts);
+  } else {
+    match(o, val, opts) && collectFull(res, s, sval);
+  }
 };
 const queryLF = (res, db, s, p, o, opts) => {
-    const sval = db[s];
-    sval != null && collectSP(res, sval, s, p, o, opts);
+  const sval = db[s];
+  sval != null && collectSP(res, sval, s, p, o, opts);
 };
 const queryLN = (res, db, s, _, o, opts) => {
-    const sval = db[s];
-    sval != null && collectSO(res, sval, s, o, opts);
+  const sval = db[s];
+  sval != null && collectSO(res, sval, s, o, opts);
 };
 const queryFL = (res, db, s, p, o, opts) => {
-    if (opts.partial) {
-        for (let $s in db) {
-            s($s) && collect(res, $s, p, o, db[$s]?.[p], opts);
-        }
+  if (opts.partial) {
+    for (let $s in db) {
+      s($s) && collect(res, $s, p, o, db[$s]?.[p], opts);
     }
-    else {
-        for (let $s in db) {
-            const sval = db[$s];
-            s($s) &&
-                match(o, sval?.[p], opts) &&
-                collectFull(res, $s, sval);
-        }
+  } else {
+    for (let $s in db) {
+      const sval = db[$s];
+      s($s) && match(o, sval?.[p], opts) && collectFull(res, $s, sval);
     }
+  }
 };
 const queryFF = (res, db, s, p, o, opts) => {
-    for (let $s in db) {
-        s($s) && collectSP(res, db[$s], $s, p, o, opts);
-    }
+  for (let $s in db) {
+    s($s) && collectSP(res, db[$s], $s, p, o, opts);
+  }
 };
 const queryFN = (res, db, s, _, o, opts) => {
-    for (let $s in db) {
-        s($s) && collectSO(res, db[$s], $s, o, opts);
-    }
+  for (let $s in db) {
+    s($s) && collectSO(res, db[$s], $s, o, opts);
+  }
 };
 const queryNL = (res, db, _, p, o, opts) => {
-    if (opts.partial) {
-        for (let s in db) {
-            collect(res, s, p, o, db[s][p], opts);
-        }
+  if (opts.partial) {
+    for (let s in db) {
+      collect(res, s, p, o, db[s][p], opts);
     }
-    else {
-        for (let s in db) {
-            const sval = db[s];
-            match(o, sval[p], opts) && collectFull(res, s, sval);
-        }
+  } else {
+    for (let s in db) {
+      const sval = db[s];
+      match(o, sval[p], opts) && collectFull(res, s, sval);
     }
+  }
 };
 const queryNF = (res, db, _, p, o, opts) => {
-    for (let s in db) {
-        collectSP(res, db[s], s, p, o, opts);
-    }
+  for (let s in db) {
+    collectSP(res, db[s], s, p, o, opts);
+  }
 };
 const queryNN = (res, db, _, __, o, opts) => {
-    for (let s in db) {
-        collectSO(res, db[s], s, o, opts);
-    }
+  for (let s in db) {
+    collectSO(res, db[s], s, o, opts);
+  }
 };
 const querySP = (res, sval, s, p, _, opts) => {
-    if (opts.partial) {
-        for (let q in sval) {
-            if (p(q)) {
-                const val = sval[q];
-                val != null && addTriple(res, s, q, val);
-            }
-        }
+  if (opts.partial) {
+    for (let q in sval) {
+      if (p(q)) {
+        const val = sval[q];
+        val != null && addTriple(res, s, q, val);
+      }
     }
-    else {
-        for (let q in sval) {
-            if (p(q)) {
-                collectFull(res, s, sval);
-                return;
-            }
-        }
+  } else {
+    for (let q in sval) {
+      if (p(q)) {
+        collectFull(res, s, sval);
+        return;
+      }
     }
+  }
 };
 const queryO = (res, db, s, p, _, opts) => {
-    const sval = db[s];
-    const val = sval?.[p];
-    val != null &&
-        (opts.partial ? addTriple(res, s, p, val) : collectFull(res, s, sval));
+  const sval = db[s];
+  const val = sval?.[p];
+  val != null && (opts.partial ? addTriple(res, s, p, val) : collectFull(res, s, sval));
 };
 const IMPLS = {
-    lll: queryLL,
-    llf: queryLL,
-    lln: queryO,
-    lfl: queryLF,
-    lff: queryLF,
-    lfn: (res, db, s, p, _, opts) => {
-        const sval = db[s];
-        sval != null && querySP(res, sval, s, p, null, opts);
-    },
-    lnl: queryLN,
-    lnf: queryLN,
-    lnn: (res, db, s) => {
-        const sval = db[s];
-        sval != null && collectFull(res, s, sval);
-    },
-    fll: queryFL,
-    flf: queryFL,
-    fln: (res, db, s, p, _, opts) => {
-        for (let $s in db) {
-            s($s) && queryO(res, db, $s, p, null, opts);
-        }
-    },
-    ffl: queryFF,
-    fff: queryFF,
-    ffn: (res, db, s, p, _, opts) => {
-        if (opts.partial) {
-            for (let $s in db) {
-                if (s($s)) {
-                    const sval = db[$s];
-                    for (let $p in sval) {
-                        p($p) && addTriple(res, $s, $p, sval[$p]);
-                    }
-                }
-            }
-        }
-        else {
-            for (let $s in db) {
-                if (s($s)) {
-                    const sval = db[$s];
-                    for (let $p in sval) {
-                        if (p($p)) {
-                            collectFull(res, $s, sval);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-    },
-    fnl: queryFN,
-    fnf: queryFN,
-    fnn: (res, db, s) => {
-        for (let $s in db) {
-            if (s($s)) {
-                const sval = db[$s];
-                sval != null && collectFull(res, $s, sval);
-            }
-        }
-    },
-    nll: queryNL,
-    nlf: queryNL,
-    nln: (res, db, _, p, __, opts) => {
-        if (opts.partial) {
-            for (let s in db) {
-                const val = db[s][p];
-                val != null && addTriple(res, s, p, val);
-            }
+  lll: queryLL,
+  llf: queryLL,
+  lln: queryO,
+  lfl: queryLF,
+  lff: queryLF,
+  lfn: (res, db, s, p, _, opts) => {
+    const sval = db[s];
+    sval != null && querySP(res, sval, s, p, null, opts);
+  },
+  lnl: queryLN,
+  lnf: queryLN,
+  lnn: (res, db, s) => {
+    const sval = db[s];
+    sval != null && collectFull(res, s, sval);
+  },
+  fll: queryFL,
+  flf: queryFL,
+  fln: (res, db, s, p, _, opts) => {
+    for (let $s in db) {
+      s($s) && queryO(res, db, $s, p, null, opts);
+    }
+  },
+  ffl: queryFF,
+  fff: queryFF,
+  ffn: (res, db, s, p, _, opts) => {
+    if (opts.partial) {
+      for (let $s in db) {
+        if (s($s)) {
+          const sval = db[$s];
+          for (let $p in sval) {
+            p($p) && addTriple(res, $s, $p, sval[$p]);
+          }
         }
-        else {
-            for (let s in db) {
-                const sval = db[s];
-                const val = sval[p];
-                val != null && collectFull(res, s, sval);
+      }
+    } else {
+      for (let $s in db) {
+        if (s($s)) {
+          const sval = db[$s];
+          for (let $p in sval) {
+            if (p($p)) {
+              collectFull(res, $s, sval);
+              break;
             }
+          }
         }
-    },
-    nfl: queryNF,
-    nff: queryNF,
-    nfn: (res, db, _, p, __, opts) => {
-        for (let s in db) {
-            querySP(res, db[s], s, p, null, opts);
-        }
-    },
-    nnl: queryNN,
-    nnf: queryNN,
-    nnn: (res, db) => Object.assign(res, db),
+      }
+    }
+  },
+  fnl: queryFN,
+  fnf: queryFN,
+  fnn: (res, db, s) => {
+    for (let $s in db) {
+      if (s($s)) {
+        const sval = db[$s];
+        sval != null && collectFull(res, $s, sval);
+      }
+    }
+  },
+  nll: queryNL,
+  nlf: queryNL,
+  nln: (res, db, _, p, __, opts) => {
+    if (opts.partial) {
+      for (let s in db) {
+        const val = db[s][p];
+        val != null && addTriple(res, s, p, val);
+      }
+    } else {
+      for (let s in db) {
+        const sval = db[s];
+        const val = sval[p];
+        val != null && collectFull(res, s, sval);
+      }
+    }
+  },
+  nfl: queryNF,
+  nff: queryNF,
+  nfn: (res, db, _, p, __, opts) => {
+    for (let s in db) {
+      querySP(res, db[s], s, p, null, opts);
+    }
+  },
+  nnl: queryNN,
+  nnf: queryNN,
+  nnn: (res, db) => Object.assign(res, db)
 };
-/**
- * Query function implementation, dispatches to one of the 27 optimized
- * functions based on given query pattern.
- *
- * @internal
- */
 const impl = defmulti((_, __, s, p, o) => classify(s) + classify(p) + classify(o), {}, IMPLS);
 const objQuery = (src, opts, args) => {
-    const isIsec = opts.cwise && opts.intersect;
-    isIsec && (opts.cwise = false);
-    let [s, p, o, out] = args;
-    out = out || {};
-    impl(out, src, coerceStr(s), coerceStr(p), coerce(o, isIsec), opts);
-    return out;
+  const isIsec = opts.cwise && opts.intersect;
+  isIsec && (opts.cwise = false);
+  let [s, p, o, out] = args;
+  out = out || {};
+  impl(
+    out,
+    src,
+    coerceStr(s),
+    coerceStr(p),
+    coerce(o, isIsec),
+    opts
+  );
+  return out;
 };
-const arrayQuery = (src, opts, p, o, collect) => {
-    const isIsec = opts.cwise && opts.intersect;
-    isIsec && (opts.cwise = false);
-    const $p = coerceStr(p);
-    const $o = coerce(o, isIsec);
-    // pre-select implementation to avoid dynamic dispatch
-    const impl = IMPLS[("n" + classify($p) + classify($o))];
-    for (let i = 0, n = src.length; i < n; i++) {
-        const res = {};
-        impl(res, { _: src[i] }, "_", $p, $o, opts);
-        res._ && collect(res._, i);
-    }
+const arrayQuery = (src, opts, p, o, collect2) => {
+  const isIsec = opts.cwise && opts.intersect;
+  isIsec && (opts.cwise = false);
+  const $p = coerceStr(p);
+  const $o = coerce(o, isIsec);
+  const impl2 = IMPLS["n" + classify($p) + classify($o)];
+  for (let i = 0, n = src.length; i < n; i++) {
+    const res = {};
+    impl2(res, { _: src[i] }, "_", $p, $o, opts);
+    res._ && collect2(res._, i);
+  }
 };
 const DEFAULT_OPTS = {
-    partial: false,
-    cwise: true,
-    intersect: false,
-    equiv,
+  partial: false,
+  cwise: true,
+  intersect: false,
+  equiv
 };
-/**
- * Generic Higher-order function to return an actual query function based on
- * given behavior options.
- *
- * @remarks
- * @see {@link QueryOpts}
- * @see {@link ObjQueryFn}
- * @see {@link ArrayQueryFn}
- * @see {@link defKeyQuery}
- *
- * @param opts -
- */
-export const defQuery = (opts) => {
-    const $opts = { ...DEFAULT_OPTS, ...opts };
-    return ((src, ...args) => {
-        if (isArray(src)) {
-            const out = args[2] || [];
-            arrayQuery(src, $opts, args[0], args[1], (x) => out.push(x));
-            return out;
-        }
-        else {
-            return objQuery(src, $opts, args);
-        }
-    });
-};
-/**
- * Generic Higher-order function to return an actual query function based on
- * given behavior options. Unlike {@link defQuery}, key query functions only
- * return sets of keys (or indices) of matching objects.
- *
- * @remarks
- * @see {@link KeyQueryOpts}
- * @see {@link ObjKeyQueryFn}
- * @see {@link ArrayKeyQueryFn}
- *
- * @param opts -
- */
-export const defKeyQuery = (opts) => {
-    const $opts = { ...DEFAULT_OPTS, ...opts };
-    return ((src, ...args) => {
-        if (isArray(src)) {
-            const out = args[2] || new Set();
-            arrayQuery(src, $opts, args[0], args[1], (_, i) => out.add(i));
-            return out;
-        }
-        else {
-            const res = objQuery(src, $opts, args.slice(0, 3));
-            const out = args[3];
-            if (!out)
-                return new Set(Object.keys(res));
-            for (let k in res)
-                out.add(k);
-            return out;
-        }
-    });
-};
-/**
- * Multi-term query function for collections (arrays) of {@link QueryObj}ects.
- * Takes a number of {@link QueryTerm}s and matches each term in succession
- * against the array of results of the previous terms (i.e. each sub-query is
- * potentially further narrowing the result set). Returns final results,
- * possibly post-processed, depending on given options.
- *
- * @remarks
- * Each {@link QueryTerm} can provide its own options and post-processing
- * function. Furthermore, global post-processing (e.g. limiting number of final
- * results, sorting by key) can be configured via `opts`.
- *
- * @param db
- * @param terms
- * @param opts
- */
-export const query = (db, terms, opts = {}) => {
-    for (let term of terms) {
-        if (!term)
-            continue;
-        db = (defQuery(term.opts)(db, term.q[0], term.q[1]));
-        term.post && (db = term.post(db));
-        if (!db.length)
-            return db;
+const defQuery = (opts) => {
+  const $opts = { ...DEFAULT_OPTS, ...opts };
+  return (src, ...args) => {
+    if (isArray(src)) {
+      const out = args[2] || [];
+      arrayQuery(src, $opts, args[0], args[1], (x) => out.push(x));
+      return out;
+    } else {
+      return objQuery(src, $opts, args);
     }
-    const limit = opts.limit || 0;
-    if (limit > 0 && limit < db.length) {
-        db.length = limit;
-    }
-    if (opts.sort) {
-        db.sort(compareByKey(opts.sort, opts.reverse ? reverse(compare) : compare));
+  };
+};
+const defKeyQuery = (opts) => {
+  const $opts = { ...DEFAULT_OPTS, ...opts };
+  return (src, ...args) => {
+    if (isArray(src)) {
+      const out = args[2] || /* @__PURE__ */ new Set();
+      arrayQuery(src, $opts, args[0], args[1], (_, i) => out.add(i));
+      return out;
+    } else {
+      const res = objQuery(src, $opts, args.slice(0, 3));
+      const out = args[3];
+      if (!out)
+        return new Set(Object.keys(res));
+      for (let k in res)
+        out.add(k);
+      return out;
     }
-    return db;
+  };
+};
+const query = (db, terms, opts = {}) => {
+  for (let term of terms) {
+    if (!term)
+      continue;
+    db = defQuery(term.opts)(
+      db,
+      term.q[0],
+      term.q[1]
+    );
+    term.post && (db = term.post(db));
+    if (!db.length)
+      return db;
+  }
+  const limit = opts.limit || 0;
+  if (limit > 0 && limit < db.length) {
+    db.length = limit;
+  }
+  if (opts.sort) {
+    db.sort(
+      compareByKey(
+        opts.sort,
+        opts.reverse ? reverse(compare) : compare
+      )
+    );
+  }
+  return db;
+};
+export {
+  defKeyQuery,
+  defQuery,
+  query
 };