shelving 1.46.1 → 1.47.3

package/db/Database.d.ts

@@ -1,7 +1,7 @@
 import { Entry, Observable, Observer, Result, Unsubscriber, Results, Validatable, Validator, Key, Data, Entries, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
 import { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
-import { Filters, Sorts, Query } from "../query/index.js";
+import { Filters, Sorts, Query, FilterProps, SortKeys } from "../query/index.js";
 /**
  * Combines a database model and a provider.
  *
@@ -14,7 +14,7 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     readonly provider: Provider;
     constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
+    query<K extends Key<V>>(collection: K, filters?: FilterProps<ValidatorType<V[K]>>, sorts?: SortKeys<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DatabaseDocument<ValidatorType<V[K]>>;
     /**
@@ -122,7 +122,7 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
     readonly id: string;
     constructor(db: Database, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DatabaseQuery<T>;
+    query(filters?: FilterProps<T>, sorts?: SortKeys<T>, limit?: number | null): DatabaseQuery<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional(): DatabaseQuery<T>;
     /**
@@ -163,8 +163,8 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
 }
 /** Database data embeds the corresponding `Document` instance and string ID into the data. */
 export declare type DocumentData<T extends Data> = T & {
-    _id: string;
-    _doc: DatabaseDocument<T>;
+    id: string;
+    doc: DatabaseDocument<T>;
 };
 /** Get the data for a document from a result for that document. */
 export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): DocumentData<T>;

package/db/Database.js

@@ -1,7 +1,7 @@
 import { callAsync, getFirstItem, throwAsync, validate, getMap, countItems, hasItems, ResultsObserver, } from "../util/index.js";
 import { DataUpdate, Update } from "../update/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
-import { Filters, Query, EqualFilter } from "../query/index.js";
+import { Filters, Sorts, Query, Filter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryRequiredError, QueryValidationError } from "./errors.js";
 /**
  * Combines a database model and a provider.
@@ -18,7 +18,7 @@ export class Database {
     }
     /** Create a query on a collection in this model. */
     query(collection, filters, sorts, limit) {
-        return new DatabaseQuery(this, this.validators[collection], collection, filters, sorts, limit);
+        return new DatabaseQuery(this, this.validators[collection], collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {
@@ -190,11 +190,11 @@ export class DatabaseDocument {
     }
     /** Create a query on this document's collection. */
     query(filters, sorts, limit) {
-        return new DatabaseQuery(this.db, this.validator, this.collection, filters, sorts, limit);
+        return new DatabaseQuery(this.db, this.validator, this.collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new DatabaseQuery(this.db, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
+        return new DatabaseQuery(this.db, this.validator, this.collection, new Filters(new Filter("id", "IS", this.id)));
     }
     /**
      * Does this document exist?
@@ -259,7 +259,7 @@ export class DatabaseDocument {
 /** Get the data for a document from a result for that document. */
 export function getDocumentData(result, ref) {
     if (result)
-        return { ...result, _id: ref.id, _doc: ref };
+        return { ...result, id: ref.id, doc: ref };
     throw new DocumentRequiredError(ref);
 }
 /** Get the data for a document from a result for that document. */

package/db/Operation.d.ts

@@ -8,10 +8,8 @@ export declare abstract class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export declare class Operations extends Operation {
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations: Nullish<Operation>[]): Operations;
     readonly operations: ImmutableArray<Operation>;
-    constructor(operations: ImmutableArray<Nullish<Operation>>);
+    constructor(...operations: Nullish<Operation>[]);
     run(db: Database): Promise<Operations>;
     /** Return a new write operations list with an additional write operation added. */
     with(...operations: Nullish<Operation>[]): {

package/db/Operation.js

@@ -1,26 +1,23 @@
-import { callAsyncSeries, isNotNullish, isNullish } from "../util/index.js";
+import { callAsyncSeries, notNullish, isNullish } from "../util/index.js";
 /** Represent a write operation on a database. */
 export class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export class Operations extends Operation {
-    constructor(operations) {
+    constructor(...operations) {
         super();
-        this.operations = operations.filter(isNotNullish);
-    }
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations) {
-        return new Operations(operations);
+        this.operations = operations.filter(notNullish);
     }
     async run(db) {
-        return new Operations(await callAsyncSeries(_write, this.operations, db));
+        const ops = await callAsyncSeries(_run, this.operations, db);
+        return new Operations(...ops);
     }
     /** Return a new write operations list with an additional write operation added. */
     with(...operations) {
         return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operations] };
     }
 }
-const _write = (operation, db) => operation.run(db);
+const _run = (operation, db) => operation.run(db);
 /** Represent a add operation made to a collection in a database. */
 export class AddOperation extends Operation {
     constructor(collection, data) {

package/firestore/client/FirestoreClientProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/firestore/lite/FirestoreLiteProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/firestore/server/FirestoreServerProvider.js

@@ -8,6 +8,7 @@ const OPERATORS = {
     IS: "==",
     NOT: "!=",
     IN: "in",
+    OUT: "not-in",
     GT: ">",
     GTE: ">=",
     LT: "<",

package/markup/render.js

@@ -40,7 +40,7 @@ function renderString(content, options) {
         if (matchedRule && matchedResult && matchedResult[0]) {
             // If index is more than zero, then add a string node before this one.
             if (matchedIndex) {
-                const prefix = content.substr(0, matchedIndex);
+                const prefix = content.slice(0, matchedIndex);
                 appendNode(nodes, renderString(prefix, options));
             }
             // Call the rule's `render()` function to generate the node.
@@ -49,7 +49,7 @@ function renderString(content, options) {
             element.rule = matchedRule;
             appendNode(nodes, renderNode(element, childOptions));
             // Decrement the content.
-            content = content.substr(matchedIndex + matchedResult[0].length);
+            content = content.slice(matchedIndex + matchedResult[0].length);
         }
         else {
             // If nothing else matched add the rest of the string as a node (presumably it doesn't have any punctuation).

package/markup/rules.js

@@ -82,9 +82,9 @@ const OL = {
 const SPLIT_OL_ITEMS = new RegExp(`\\n+(?=${ORDERED})`, "g");
 const mapOrderedItem = (item, key) => {
     const firstSpace = item.indexOf(" ");
-    const value = parseInt(item.substr(0, firstSpace), 10);
+    const value = parseInt(item.slice(0, firstSpace), 10);
     const children = item
-        .substr(firstSpace + 1)
+        .slice(firstSpace + 1)
         .trimStart()
         .replace(REPLACE_INDENT, "");
     return { type: "li", key, props: { value, children } };

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.46.1",
+	"version": "1.47.3",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/query/Filter.d.ts

@@ -1,59 +1,21 @@
-import { Data, Entry, Matchable, Entries, ImmutableArray } from "../util/index.js";
+import { Data, Entry, Matchable, Entries, Key } from "../util/index.js";
 import { Rule } from "./Rule.js";
-import { FilterOperator, QueryKey } from "./types.js";
+import { FilterKey, FilterOperator } from "./types.js";
 /**
  * Filter: filters a list of documents.
  *
  * @param key The name of a property that might exist on documents in the collection.
- * @param type MatchType reference, e.g. `is` or `contains`
+ * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export declare abstract class Filter<T extends Data, V extends unknown = unknown> extends Rule<T> implements Matchable<Entry<T>, void> {
-    abstract readonly operator: FilterOperator;
-    readonly key: QueryKey<T>;
-    readonly value: V;
-    constructor(key: QueryKey<T>, value: V);
-    abstract match([id, data]: Entry<T>, target: void): boolean;
+export declare class Filter<T extends Data> extends Rule<T> implements Matchable<Entry<T>, void> {
+    /** Parse a set of FilterProps and return the corresponding array of `Filter` instances. */
+    static on<X extends Data>(key: FilterKey<X>, value: unknown): Filter<X>;
+    readonly key: "id" | Key<T>;
+    readonly operator: FilterOperator;
+    readonly value: unknown;
+    constructor(key: "id" | Key<T>, operator: FilterOperator, value: unknown);
+    match([id, data]: Entry<T>): boolean;
     transform(entries: Entries<T>): Entries<T>;
     toString(): string;
 }
-/** Filter a set of values with an `IS` clause. */
-export declare class EqualFilter<T extends Data> extends Filter<T> {
-    readonly operator = "IS";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `NOT` clause. */
-export declare class NotEqualFilter<T extends Data> extends Filter<T> {
-    readonly operator = "NOT";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `IS` clause. */
-export declare class InArrayFilter<T extends Data> extends Filter<T, ImmutableArray> {
-    readonly operator = "IN";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with a `CONTAINS` clause. */
-export declare class ArrayWithFilter<T extends Data> extends Filter<T> {
-    readonly operator = "CONTAINS";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `LT` clause. */
-export declare class LessFilter<T extends Data> extends Filter<T> {
-    readonly operator = "LT";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `LTE` clause. */
-export declare class EqualLessFilter<T extends Data> extends Filter<T> {
-    readonly operator = "LTE";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `GT` clause. */
-export declare class GreaterFilter<T extends Data> extends Filter<T> {
-    readonly operator = "GT";
-    match([id, data]: Entry<T>): boolean;
-}
-/** Filter a set of values with an `GTE` clause. */
-export declare class EqualGreaterFilter<T extends Data> extends Filter<T> {
-    readonly operator = "GTE";
-    match([id, data]: Entry<T>): boolean;
-}

package/query/Filter.js

@@ -1,103 +1,55 @@
-import { match, isArrayWith, isEqual, isGreater, isEqualGreater, isInArray, isLess, isEqualLess, isNotEqual, yieldFiltered } from "../util/index.js";
+import { match, isArrayWith, isEqual, isGreater, isEqualGreater, isLess, isEqualLess, notEqual, yieldFiltered, notInArray, isInArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 import { getQueryProp } from "./helpers.js";
+/** Map `FilterOperator` to its corresponding `Matcher` function. */
+const MATCHERS = {
+    IS: isEqual,
+    NOT: notEqual,
+    IN: isInArray,
+    OUT: notInArray,
+    CONTAINS: isArrayWith,
+    LT: isLess,
+    LTE: isEqualLess,
+    GT: isGreater,
+    GTE: isEqualGreater,
+};
 /**
  * Filter: filters a list of documents.
  *
  * @param key The name of a property that might exist on documents in the collection.
- * @param type MatchType reference, e.g. `is` or `contains`
+ * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
 export class Filter extends Rule {
-    constructor(key, value) {
+    constructor(key, operator, value) {
         super();
         this.key = key;
+        this.operator = operator;
         this.value = value;
     }
+    /** Parse a set of FilterProps and return the corresponding array of `Filter` instances. */
+    static on(key, value) {
+        return key.startsWith("!")
+            ? new Filter(key.slice(1), value instanceof Array ? "OUT" : "NOT", value)
+            : key.endsWith(">")
+                ? new Filter(key.slice(0, -1), "GT", value)
+                : key.endsWith(">=")
+                    ? new Filter(key.slice(0, -2), "GTE", value)
+                    : key.endsWith("<")
+                        ? new Filter(key.slice(0, -1), "LT", value)
+                        : key.endsWith("<=")
+                            ? new Filter(key.slice(0, -2), "LTE", value)
+                            : key.endsWith("[]")
+                                ? new Filter(key.slice(0, -2), "CONTAINS", value)
+                                : new Filter(key, value instanceof Array ? "IN" : "IS", value);
+    }
+    match([id, data]) {
+        return match(getQueryProp(id, data, this.key), MATCHERS[this.operator], this.value);
+    }
     transform(entries) {
         return yieldFiltered(entries, this);
     }
     toString() {
-        return `${this.key}:${this.operator}=${JSON.stringify(this.value)}`;
-    }
-}
-/** Filter a set of values with an `IS` clause. */
-export class EqualFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "IS";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqual, this.value);
-    }
-}
-/** Filter a set of values with an `NOT` clause. */
-export class NotEqualFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "NOT";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isNotEqual, this.value);
-    }
-}
-/** Filter a set of values with an `IS` clause. */
-export class InArrayFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "IN";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isInArray, this.value);
-    }
-}
-/** Filter a set of values with a `CONTAINS` clause. */
-export class ArrayWithFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "CONTAINS";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isArrayWith, this.value);
-    }
-}
-/** Filter a set of values with an `LT` clause. */
-export class LessFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "LT";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isLess, this.value);
-    }
-}
-/** Filter a set of values with an `LTE` clause. */
-export class EqualLessFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "LTE";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqualLess, this.value);
-    }
-}
-/** Filter a set of values with an `GT` clause. */
-export class GreaterFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "GT";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isGreater, this.value);
-    }
-}
-/** Filter a set of values with an `GTE` clause. */
-export class EqualGreaterFilter extends Filter {
-    constructor() {
-        super(...arguments);
-        this.operator = "GTE";
-    }
-    match([id, data]) {
-        return match(getQueryProp(id, data, this.key), isEqualGreater, this.value);
+        return `${this.key}:${this.operator}:${JSON.stringify(this.value)}`;
     }
 }

package/query/Filters.d.ts

@@ -1,18 +1,17 @@
 import { Entry, Data, Key, Entries, ImmutableArray, ArrayType } from "../util/index.js";
-import type { Filterable, QueryKey } from "./types.js";
+import type { Filterable, FilterProps } from "./types.js";
 import { Filter } from "./Filter.js";
 import { Rules } from "./Rules.js";
 /** A set of filters. */
 export declare class Filters<T extends Data> extends Rules<T, Filter<T>> implements Filterable<T> {
-    is<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    not<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    in<K extends QueryKey<T>>(key: K, value: K extends "id" ? readonly string[] : readonly T[K][]): this;
-    contains<K extends Key<T>>(key: K, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
-    lt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    lte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
+    /** Create a `Filters` instance from a set of `FilterProps` */
+    static on<X extends Data>(filters: FilterProps<X>): Filters<X>;
+    filter(props: FilterProps<T>): this;
+    filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
+    filter(key: "id" | "!id", value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     match(entry: Entry<T>): boolean;
-    get unfiltered(): this;
     transform(iterable: Entries<T>): Entries<T>;
 }

package/query/Filters.js

@@ -1,32 +1,18 @@
 import { yieldFiltered } from "../util/index.js";
-import { ArrayWithFilter, EqualFilter, EqualGreaterFilter, GreaterFilter, InArrayFilter, EqualLessFilter, LessFilter, NotEqualFilter } from "./Filter.js";
+import { Filter } from "./Filter.js";
 import { Rules } from "./Rules.js";
+function* _yieldFilters(props) {
+    for (const [key, value] of Object.entries(props))
+        yield Filter.on(key, value);
+}
 /** A set of filters. */
 export class Filters extends Rules {
-    // Implement `Filterable`
-    is(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualFilter(key, value)] };
-    }
-    not(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new NotEqualFilter(key, value)] };
-    }
-    in(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new InArrayFilter(key, value)] };
-    }
-    contains(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new ArrayWithFilter(key, value)] };
+    /** Create a `Filters` instance from a set of `FilterProps` */
+    static on(filters) {
+        return new Filters(..._yieldFilters(filters));
     }
-    lt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new LessFilter(key, value)] };
-    }
-    lte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualLessFilter(key, value)] };
-    }
-    gt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new GreaterFilter(key, value)] };
-    }
-    gte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new EqualGreaterFilter(key, value)] };
+    filter(input, value) {
+        return typeof input === "string" ? this.with(Filter.on(input, value)) : this.with(..._yieldFilters(input));
     }
     match(entry) {
         for (const rule of this._rules)
@@ -34,9 +20,6 @@ export class Filters extends Rules {
                 return false;
         return true;
     }
-    get unfiltered() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [] };
-    }
     // Implement `Rule`
     transform(iterable) {
         return this._rules.length ? yieldFiltered(iterable, this) : iterable;

package/query/Query.d.ts

@@ -1,27 +1,26 @@
 import { Data, Entry, Key, Entries, ArrayType, ImmutableArray } from "../util/index.js";
-import type { Queryable, QueryKey } from "./types.js";
+import type { Queryable, SortKey, FilterProps, SortKeys } from "./types.js";
 import { Filters } from "./Filters.js";
 import { Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 /** Allows filtering, sorting, and limiting on a set of results. */
 export declare class Query<T extends Data> extends Rule<T> implements Queryable<T> {
+    /** Create a new `Query` object from a set of `QueryProps` */
+    static on<X extends Data>(filters?: FilterProps<X>, sorts?: SortKey<X> | ImmutableArray<SortKey<X>>, limit?: number | null): Query<X>;
     readonly filters: Filters<T>;
     readonly sorts: Sorts<T>;
     readonly limit: number | null;
     constructor(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null);
-    is<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    not<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    in<K extends QueryKey<T>>(key: K, value: K extends "id" ? readonly string[] : readonly T[K][]): this;
-    contains<K extends Key<T>>(key: K, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
-    lt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    lte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    get unfiltered(): this;
+    filter(props: FilterProps<T>): this;
+    filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
+    filter(key: "id" | "!id", value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<T[K]>): this;
+    filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
+    get unfilter(): this;
     match(entry: Entry<T>): boolean;
-    asc(key: QueryKey<T>): this;
-    desc(key: QueryKey<T>): this;
-    get unsorted(): this;
+    sort(...keys: SortKeys<T>[]): this;
+    get unsort(): this;
     rank(left: Entry<T>, right: Entry<T>): number;
     /** Return a new instance of this class with a limit defined. */
     max(limit: number | null): this;

package/query/Query.js

@@ -3,7 +3,7 @@ import { Filters } from "./Filters.js";
 import { Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 import { getQueryProp } from "./helpers.js";
-import { EqualGreaterFilter as GTE, GreaterFilter as GT, EqualLessFilter as LTE, LessFilter as LT } from "./Filter.js";
+import { Filter } from "./Filter.js";
 // Instances to save resources for the default case (empty query).
 const EMPTY_FILTERS = new Filters(); // eslint-disable-line @typescript-eslint/no-explicit-any
 const EMPTY_SORTS = new Sorts(); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -15,46 +15,25 @@ export class Query extends Rule {
         this.sorts = sorts;
         this.limit = limit;
     }
-    // Implement `Filterable`
-    is(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.is(key, value) };
+    /** Create a new `Query` object from a set of `QueryProps` */
+    static on(filters, sorts, limit) {
+        return new Query(filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
     }
-    not(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.not(key, value) };
+    filter(input, value) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.filter(input, value) };
     }
-    in(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.in(key, value) };
-    }
-    contains(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.contains(key, value) };
-    }
-    lt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.lt(key, value) };
-    }
-    lte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.lte(key, value) };
-    }
-    gt(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.gt(key, value) };
-    }
-    gte(key, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.gte(key, value) };
-    }
-    get unfiltered() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.unfiltered };
+    get unfilter() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, filters: EMPTY_FILTERS };
     }
     match(entry) {
         return this.filters.match(entry);
     }
     // Implement `Sortable`
-    asc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.asc(key) };
-    }
-    desc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.desc(key) };
+    sort(...keys) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.sort(...keys) };
     }
-    get unsorted() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.unsorted };
+    get unsort() {
+        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: EMPTY_SORTS };
     }
     rank(left, right) {
         return this.sorts.rank(left, right);
@@ -69,8 +48,8 @@ export class Query extends Rule {
         const lastSort = this.sorts.last;
         assert(lastSort);
         for (const sort of this.sorts) {
-            const AppliedFilter = sort.direction === "ASC" ? (sort === lastSort ? GT : GTE) : sort === lastSort ? LT : LTE;
-            filters.push(new AppliedFilter(sort.key, getQueryProp(id, data, sort.key)));
+            const { key, direction } = sort;
+            filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "GT" : "GTE") : sort === lastSort ? "LT" : "LTE", getQueryProp(id, data, key)));
         }
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
     }
@@ -79,8 +58,8 @@ export class Query extends Rule {
         const lastSort = this.sorts.last;
         assert(lastSort);
         for (const sort of this.sorts) {
-            const AppliedFilter = sort.direction === "ASC" ? (sort === lastSort ? LT : LTE) : sort === lastSort ? GT : GTE;
-            filters.push(new AppliedFilter(sort.key, getQueryProp(id, data, sort.key)));
+            const { key, direction } = sort;
+            filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "LT" : "LTE") : sort === lastSort ? "GT" : "GTE", getQueryProp(id, data, key)));
         }
         return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
     }

package/query/Rules.d.ts

@@ -1,8 +1,8 @@
-import { Data, MutableArray } from "../util/index.js";
+import { Data, ImmutableArray } from "../util/index.js";
 import { Rule } from "./Rule.js";
 /** Type of Rule that is powered by several sub-rules (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export declare abstract class Rules<T extends Data, R extends Rule<T>> extends Rule<T> implements Iterable<R> {
-    protected readonly _rules: MutableArray<R>;
+    protected readonly _rules: ImmutableArray<R>;
     /** Get the first rule. */
     get first(): R | undefined;
     /** Get the last rule. */
@@ -11,6 +11,10 @@ export declare abstract class Rules<T extends Data, R extends Rule<T>> extends R
     get size(): number;
     constructor(...rules: R[]);
     toString(): string;
+    /** Clone this set of rules but add additional rules. */
+    with(...rules: R[]): this;
+    /** Clone this set of rules but remove specific rules. */
+    without(...rules: R[]): this;
     /** Iterate over the rules. */
     [Symbol.iterator](): Iterator<R, void>;
 }

package/query/Rules.js

@@ -1,4 +1,4 @@
-import { toString } from "../util/index.js";
+import { toString, withItems, withoutItems } from "../util/index.js";
 import { Rule } from "./Rule.js";
 /** Type of Rule that is powered by several sub-rules (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Rules extends Rule {
@@ -21,6 +21,16 @@ export class Rules extends Rule {
     toString() {
         return this._rules.map(toString).join("&");
     }
+    /** Clone this set of rules but add additional rules. */
+    with(...rules) {
+        const _rules = withItems(this._rules, rules);
+        return _rules !== this._rules ? { __proto__: Object.getPrototypeOf(this), ...this, _rules } : this;
+    }
+    /** Clone this set of rules but remove specific rules. */
+    without(...rules) {
+        const _rules = withoutItems(this._rules, rules);
+        return _rules !== this._rules ? { __proto__: Object.getPrototypeOf(this), ...this, _rules } : this;
+    }
     /** Iterate over the rules. */
     [Symbol.iterator]() {
         return this._rules.values();

package/query/Sort.d.ts

@@ -1,22 +1,14 @@
-import { Data, Entry, Rankable, Entries } from "../util/index.js";
+import { Data, Entry, Rankable, Entries, Key } from "../util/index.js";
 import { Rule } from "./Rule.js";
-import { QueryKey, SortDirection } from "./types.js";
+import { SortDirection, SortKey } from "./types.js";
 /** Sort a list of values. */
-export declare abstract class Sort<T extends Data> extends Rule<T> implements Rankable<Entry<T>> {
-    abstract readonly direction: SortDirection;
-    readonly key: QueryKey<T>;
-    constructor(key: QueryKey<T>);
-    abstract rank(left: Entry<T>, right: Entry<T>): number;
+export declare class Sort<T extends Data> extends Rule<T> implements Rankable<Entry<T>> {
+    /** Create a sort on a specified field. */
+    static on<X extends Data>(sort: SortKey<X> | Sort<X>): Sort<X>;
+    readonly key: "id" | Key<T>;
+    readonly direction: SortDirection;
+    constructor(key: "id" | Key<T>, direction: SortDirection);
+    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
     transform(iterable: Entries<T>): Entries<T>;
     toString(): string;
 }
-/** Sort a list of values in ascending order. */
-export declare class AscendingSort<T extends Data> extends Sort<T> {
-    readonly direction = "ASC";
-    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
-}
-/** Sort a list of values in descending order. */
-export declare class DescendingSort<T extends Data> extends Sort<T> {
-    readonly direction = "DESC";
-    rank([leftId, leftData]: Entry<T>, [rightId, rightData]: Entry<T>): number;
-}

package/query/Sort.js

@@ -1,36 +1,24 @@
-import { rankAscending, rank, rankDesc, sortItems } from "../util/index.js";
+import { rankAsc, rank, sortItems, rankDesc } from "../util/index.js";
 import { getQueryProp } from "./helpers.js";
 import { Rule } from "./Rule.js";
 /** Sort a list of values. */
 export class Sort extends Rule {
-    constructor(key) {
+    constructor(key, direction) {
         super();
         this.key = key;
+        this.direction = direction;
     }
-    transform(iterable) {
-        return sortItems(iterable, this);
-    }
-    toString() {
-        return `${this.key}:${this.direction}`;
-    }
-}
-/** Sort a list of values in ascending order. */
-export class AscendingSort extends Sort {
-    constructor() {
-        super(...arguments);
-        this.direction = "ASC";
+    /** Create a sort on a specified field. */
+    static on(sort) {
+        return sort instanceof Sort ? sort : sort.startsWith("!") ? new Sort(sort.slice(1), "DESC") : new Sort(sort, "ASC");
     }
     rank([leftId, leftData], [rightId, rightData]) {
-        return rank(getQueryProp(leftId, leftData, this.key), rankAscending, getQueryProp(rightId, rightData, this.key));
+        return rank(getQueryProp(leftId, leftData, this.key), this.direction === "ASC" ? rankAsc : rankDesc, getQueryProp(rightId, rightData, this.key));
     }
-}
-/** Sort a list of values in descending order. */
-export class DescendingSort extends Sort {
-    constructor() {
-        super(...arguments);
-        this.direction = "DESC";
+    transform(iterable) {
+        return sortItems(iterable, this);
     }
-    rank([leftId, leftData], [rightId, rightData]) {
-        return rank(getQueryProp(leftId, leftData, this.key), rankDesc, getQueryProp(rightId, rightData, this.key));
+    toString() {
+        return `${this.direction === "DESC" ? "!" : ""}${this.key}`;
     }
 }

package/query/Sorts.d.ts

@@ -1,12 +1,12 @@
 import { Entry, Data, Entries } from "../util/index.js";
-import type { QueryKey, Sortable } from "./types.js";
+import type { Sortable, SortKeys } from "./types.js";
 import { Sort } from "./Sort.js";
 import { Rules } from "./Rules.js";
 /** A set of sorts. */
 export declare class Sorts<T extends Data> extends Rules<T, Sort<T>> implements Sortable<T> {
-    asc(key: QueryKey<T>): this;
-    desc(key: QueryKey<T>): this;
-    get unsorted(): this;
+    /** Create a new `Sorts` object from an array of `SortKey` strings. */
+    static on<X extends Data>(...keys: SortKeys<X>[]): Sorts<X>;
+    sort(...keys: SortKeys<T>[]): this;
     rank(left: Entry<T>, right: Entry<T>): number;
     transform(iterable: Entries<T>): Entries<T>;
 }

package/query/Sorts.js

@@ -1,17 +1,15 @@
 import { sortItems } from "../util/index.js";
-import { AscendingSort, DescendingSort } from "./Sort.js";
+import { Sort } from "./Sort.js";
 import { Rules } from "./Rules.js";
 /** A set of sorts. */
 export class Sorts extends Rules {
-    // Implement `Sortable`
-    asc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new AscendingSort(key)] };
-    }
-    desc(key) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [...this._rules, new DescendingSort(key)] };
+    /** Create a new `Sorts` object from an array of `SortKey` strings. */
+    static on(...keys) {
+        return new Sorts(...keys.flat().map(Sort.on));
     }
-    get unsorted() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, _rules: [] };
+    // Implement `Sortable`
+    sort(...keys) {
+        return this.with(...keys.flat().map(Sort.on));
     }
     rank(left, right) {
         for (const rule of this._rules) {

package/query/helpers.d.ts

@@ -1,9 +1,8 @@
-import { Data } from "../util/index.js";
-import type { QueryKey } from "./types.js";
+import { Data, Key } from "../util/index.js";
 /**
  * Get a named property value from some data.
  * - For using in `Query` and `Filter` and `Sort` etc.
  * - `"id"` is a special case and always returns the ID.
  * - Anything else assumes the entry value is an object and looks up that named prop in the data.
  */
-export declare const getQueryProp: <T extends Data, K extends QueryKey<T>>(id: string, data: T, key: K) => K extends "id" ? string : T[K];
+export declare const getQueryProp: <T extends Data, K extends "id" | Key<T>>(id: string, data: T, key: K) => K extends "id" ? string : T[K];

package/query/types.d.ts

@@ -1,40 +1,52 @@
 import type { Data, Key, Matchable, Entry, Rankable, ImmutableArray, ArrayType } from "../util/index.js";
-/** Type for a key in a query, either `id` for the unique ID of the document or any other string key that exists in data. */
-export declare type QueryKey<T extends Data> = "id" | Key<T>;
 /** Possible operator references. */
-export declare type FilterOperator = "IS" | "NOT" | "IN" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+/** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
+export declare type FilterKey<T extends Data> = "id" | "!id" | "id>" | "id>=" | "id<" | "id<=" | Key<T> | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
+/** Format that allows multiple filters to be specified as a plain object. */
+export declare type FilterProps<T extends Data> = {
+    "id"?: string | ImmutableArray<string>;
+    "!id"?: string | ImmutableArray<string>;
+    "id>"?: string;
+    "id>="?: string;
+    "id<"?: string;
+    "id<="?: string;
+} & {
+    [K in Key<T> as K | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+} & {
+    [K in Key<T> as `${K}[]`]?: T[K] extends ImmutableArray ? ArrayType<T[K]> : never;
+} & {
+    [K in Key<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+};
 /**
  * Interface to make sure an object implements all matchers.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
  */
 export interface Filterable<T extends Data> extends Matchable<Entry<T>, void> {
-    is<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    not<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    in<K extends QueryKey<T>>(key: K, value: K extends "id" ? readonly string[] : readonly T[K][]): this;
-    contains<K extends Key<T>>(key: K, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
-    lt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    lte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gt<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    gte<K extends QueryKey<T>>(key: K, value: K extends "id" ? string : T[K]): this;
-    /** Return a new instance of this class with no sorts specified. */
-    unfiltered: this;
+    /** Add a filter to this filterable. */
+    filter(props: FilterProps<T>): this;
+    filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
+    filter(key: "id" | "!id", value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     /** Match an entry against the filters specified for this object. */
     match(entry: Entry<T>): boolean;
 }
+/** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
+export declare type SortKey<T extends Data> = "id" | "!id" | Key<T> | `!${Key<T>}`;
+/** One or more sort keys. */
+export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
+/** Possible operator references. */
+export declare type SortDirection = "ASC" | "DESC";
 /**
  * Interface to make sure an object implements all directions.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
  */
 export interface Sortable<T extends Data> extends Rankable<Entry<T>> {
-    /** Return a new instance of this class with an ascending order sort defined. */
-    asc(key: QueryKey<T>): this;
-    /** Return a new instance of this class with a descending order sort defined. */
-    desc(key: QueryKey<T>): this;
-    /** Return a new instance of this class with no sorts specified. */
-    unsorted: this;
+    /** Add one or more sorts to this sortable. */
+    sort(...keys: SortKeys<T>[]): this;
 }
-/** Possible operator references. */
-export declare type SortDirection = "ASC" | "DESC";
 /** Interface for an object that can have a limit set. */
 export interface Limitable {
     /** The maximum number of items allowed by the limit. */
@@ -55,4 +67,8 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T>, L
     after(id: string, data: T): this;
     /** Return a new instance of this class with a before offset defined. */
     before(id: string, data: T): this;
+    /** Return a new instance of this class with no filters specified. */
+    unfilter: this;
+    /** Return a new instance of this class with no sorts specified. */
+    unsort: this;
 }

package/schema/PhoneSchema.js

@@ -21,7 +21,7 @@ export class PhoneSchema extends StringSchema {
         // Strip characters that aren't 0-9 or `+` plus (including whitespace).
         const digits = str.replace(/[^0-9+]/g, "");
         // Allow `+` plus only if it's first character.
-        return digits.substr(0, 1) + digits.substr(1).replace(/[^0-9]/g, "");
+        return digits.slice(0, 1) + digits.slice(1).replace(/[^0-9]/g, "");
     }
 }
 /** Valid phone number, e.g. `+441234567890` */

package/test/util.js

@@ -34,7 +34,7 @@ function popErrorStack(error, count = 1) {
         const prefix = message ? `${name}: ${message}\n` : `${name}\n`;
         if (stack.startsWith(prefix)) {
             // In Chrome and Node the name and message of the error is the first line of the stack (so we need to skip over the first line).
-            const lines = stack.substr(prefix.length).split("\n");
+            const lines = stack.slice(prefix.length).split("\n");
             lines.splice(0, count);
             error.stack = prefix + lines.join("\n");
         }

package/util/date.js

@@ -64,11 +64,11 @@ export function getDate(target = "now") {
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `null` if it couldn't be converted. */
 export function toYmd(target) {
     const date = toDate(target);
-    return date ? date.toISOString().substr(0, 10) : null;
+    return date ? date.toISOString().slice(0, 10) : null;
 }
 /** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
 export function getYmd(target = "now") {
-    return getDate(target).toISOString().substr(0, 10);
+    return getDate(target).toISOString().slice(0, 10);
 }
 /** List of day-of-week strings. */
 export const days = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/debug.js

@@ -16,7 +16,7 @@ export const debug = (value) => typeof value === "function"
                         : typeof value === "string"
                             ? debugString(value)
                             : typeof value;
-const debugString = (value) => (value.length > DEBUG_STRING_MAX ? `"${value.substr(0, DEBUG_STRING_MAX)}…"` : `"${value}"`);
+const debugString = (value) => (value.length > DEBUG_STRING_MAX ? `"${value.slice(0, DEBUG_STRING_MAX)}…"` : `"${value}"`);
 const DEBUG_STRING_MAX = 23;
 const debugObject = (value) => {
     const prototype = Object.getPrototypeOf(value);

package/util/filter.d.ts

@@ -13,23 +13,26 @@ export declare type Matcher<L, R> = Matchable<L, R> | ((item: L, target: R) => b
 export declare function match<L>(item: L, matcher: Matcher<L, void>): boolean;
 export declare function match<L, R>(item: L, matcher: Matcher<L, R>, target: R): boolean;
 export declare const isEqual: <T>(item: unknown, target: T) => item is T;
-export declare const isNotEqual: <T, N>(item: T | N, target: T) => item is N;
+export declare const notEqual: <T, N>(item: T | N, target: T) => item is N;
 export declare const isInArray: <T>(item: unknown, targets: ImmutableArray<T>) => item is T;
+export declare const notInArray: <T, N>(item: T | N, targets: ImmutableArray<T>) => item is N;
 export declare const isArrayWith: (items: unknown, target: unknown) => boolean;
 export declare const isLess: (item: unknown, target: unknown) => boolean;
 export declare const isEqualLess: (item: unknown, target: unknown) => boolean;
 export declare const isGreater: (item: unknown, target: unknown) => boolean;
 export declare const isEqualGreater: (item: unknown, target: unknown) => boolean;
 export declare const isKeyEqual: ([key]: Entry<unknown>, target: string) => boolean;
-export declare const isKeyNotEqual: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const notKeyEqual: ([key]: Entry<unknown>, targets: string) => boolean;
 export declare const isKeyInArray: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const notKeyInArray: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
 export declare const isKeyLess: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyEqualLess: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyGreater: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isKeyEqualGreater: ([key]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
-export declare const isValueNotEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const notValueEqual: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueInArray: ([, value]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
+export declare const notValueInArray: ([, value]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
 export declare const isValueLess: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueEqualLess: ([, value]: Entry<unknown>, target: unknown) => boolean;
 export declare const isValueGreater: ([, value]: Entry<unknown>, target: unknown) => boolean;

package/util/filter.js

@@ -1,29 +1,32 @@
-import { rankAscending } from "./sort.js";
+import { rankAsc } from "./sort.js";
 import { transform } from "./transform.js";
 export function match(item, matcher, target) {
     return typeof matcher === "function" ? matcher(item, target) : matcher.match(item, target);
 }
 // Regular matchers.
 export const isEqual = (item, target) => item === target;
-export const isNotEqual = (item, target) => item !== target;
+export const notEqual = (item, target) => item !== target;
 export const isInArray = (item, targets) => targets.includes(item);
+export const notInArray = (item, targets) => !targets.includes(item);
 export const isArrayWith = (items, target) => items instanceof Array && items.includes(target);
-export const isLess = (item, target) => rankAscending(item, target) < 0;
-export const isEqualLess = (item, target) => rankAscending(item, target) <= 0;
-export const isGreater = (item, target) => rankAscending(item, target) > 0;
-export const isEqualGreater = (item, target) => rankAscending(item, target) >= 0;
+export const isLess = (item, target) => rankAsc(item, target) < 0;
+export const isEqualLess = (item, target) => rankAsc(item, target) <= 0;
+export const isGreater = (item, target) => rankAsc(item, target) > 0;
+export const isEqualGreater = (item, target) => rankAsc(item, target) >= 0;
 // Entry key matchers.
 export const isKeyEqual = ([key], target) => isEqual(key, target);
-export const isKeyNotEqual = ([key], targets) => isNotEqual(key, targets);
+export const notKeyEqual = ([key], targets) => notEqual(key, targets);
 export const isKeyInArray = ([key], targets) => isInArray(key, targets);
+export const notKeyInArray = ([key], targets) => notInArray(key, targets);
 export const isKeyLess = ([key], target) => isLess(key, target);
 export const isKeyEqualLess = ([key], target) => isEqualLess(key, target);
 export const isKeyGreater = ([key], target) => isGreater(key, target);
 export const isKeyEqualGreater = ([key], target) => isEqualGreater(key, target);
 // Entry value matchers.
 export const isValueEqual = ([, value], target) => isEqual(value, target);
-export const isValueNotEqual = ([, value], target) => isNotEqual(value, target);
+export const notValueEqual = ([, value], target) => notEqual(value, target);
 export const isValueInArray = ([, value], targets) => isInArray(value, targets);
+export const notValueInArray = ([, value], targets) => notInArray(value, targets);
 export const isValueLess = ([, value], target) => isLess(value, target);
 export const isValueEqualLess = ([, value], target) => isEqualLess(value, target);
 export const isValueGreater = ([, value], target) => isGreater(value, target);

package/util/null.d.ts

@@ -1,7 +1,7 @@
 /** Is a value null? */
 export declare const isNull: (v: unknown) => v is null;
 /** Is a value not null? */
-export declare const isNotNull: <T>(v: T | null) => v is T;
+export declare const notNull: <T>(v: T | null) => v is T;
 /** Function that always returns null. */
 export declare const NULL: () => null;
 /** Nullish is `null` or `undefined` */
@@ -11,7 +11,7 @@ export declare type NotNullish<T> = Exclude<T, null | undefined>;
 /** Is a value nullish? */
 export declare const isNullish: <T>(v: Nullish<T>) => v is null | undefined;
 /** Is a value not nullish? */
-export declare const isNotNullish: <T>(v: Nullish<T>) => v is T;
+export declare const notNullish: <T>(v: Nullish<T>) => v is T;
 /** Get a required value (returns value or throws `RequiredError` if value is `null` or `undefined`). */
 export declare function getRequired<T>(v: T): NotNullish<T>;
 export declare function getRequired<T>(v: Nullish<T>): T;

package/util/null.js

@@ -2,13 +2,13 @@ import { RequiredError } from "../error/index.js";
 /** Is a value null? */
 export const isNull = (v) => v === null;
 /** Is a value not null? */
-export const isNotNull = (v) => v !== null;
+export const notNull = (v) => v !== null;
 /** Function that always returns null. */
 export const NULL = () => null;
 /** Is a value nullish? */
 export const isNullish = (v) => v === null || v === undefined;
 /** Is a value not nullish? */
-export const isNotNullish = (v) => v !== null && v !== undefined;
+export const notNullish = (v) => v !== null && v !== undefined;
 export function getRequired(v) {
     if (v === undefined || v === null)
         throw new RequiredError("Required value is missing");

package/util/sort.d.ts

@@ -28,17 +28,17 @@ export declare function rank<T>(left: T, ranker: Ranker<T>, right: T): number;
  *
  * @returns Number below zero if `a` is higher, number above zero if `b` is higher, or `0` if they're equally sorted.
  */
-export declare function rankAscending(left: unknown, right: unknown): number;
+export declare function rankAsc(left: unknown, right: unknown): number;
 /** Rank two values in descending order. */
 export declare const rankDesc: (left: unknown, right: unknown) => number;
 /** Rank the keys of two entries in ascending order. */
-export declare const rankEntryKeyAsc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
+export declare const rankKeyAsc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
 /** Rank the keys of two entries in descending order. */
-export declare const rankEntryKeyDesc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
+export declare const rankKeyDesc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
 /** Rank the values of two entries in ascending order. */
-export declare const rankEntryValueAsc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
+export declare const rankValueAsc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
 /** Rank the values of two entries in descending order. */
-export declare const rankEntryValueDesc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
+export declare const rankValueDesc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
 /** Sort an iterable set of items using a ranker (defaults to sorting in ascending order). */
 export declare function sortItems<T>(input: Iterable<T>, ranker?: Ranker<T>): ImmutableArray<T>;
 /** Sort an array using a ranker (defaults to sorting in ascending order) */

package/util/sort.js

@@ -20,7 +20,7 @@ export function rank(left, ranker, right) {
  *
  * @returns Number below zero if `a` is higher, number above zero if `b` is higher, or `0` if they're equally sorted.
  */
-export function rankAscending(left, right) {
+export function rankAsc(left, right) {
     // Exactly equal is easy.
     if (left === right)
         return 0;
@@ -73,15 +73,15 @@ export function rankAscending(left, right) {
     return -1;
 }
 /** Rank two values in descending order. */
-export const rankDesc = (left, right) => 0 - rankAscending(left, right);
+export const rankDesc = (left, right) => 0 - rankAsc(left, right);
 /** Rank the keys of two entries in ascending order. */
-export const rankEntryKeyAsc = ([l], [r]) => rankAscending(l, r);
+export const rankKeyAsc = ([l], [r]) => rankAsc(l, r);
 /** Rank the keys of two entries in descending order. */
-export const rankEntryKeyDesc = ([l], [r]) => rankDesc(l, r);
+export const rankKeyDesc = ([l], [r]) => rankDesc(l, r);
 /** Rank the values of two entries in ascending order. */
-export const rankEntryValueAsc = ([, l], [, r]) => rankAscending(l, r);
+export const rankValueAsc = ([, l], [, r]) => rankAsc(l, r);
 /** Rank the values of two entries in descending order. */
-export const rankEntryValueDesc = ([, l], [, r]) => rankDesc(l, r);
+export const rankValueDesc = ([, l], [, r]) => rankDesc(l, r);
 /**
  * Quick sort algorithm.
  * DH: We implement our own sorting algorithm so that:
@@ -130,13 +130,13 @@ function _quicksort(items, ranker, leftPointer = 0, rightPointer = items.length
     return changed;
 }
 /** Sort an iterable set of items using a ranker (defaults to sorting in ascending order). */
-export function sortItems(input, ranker = rankAscending) {
+export function sortItems(input, ranker = rankAsc) {
     const array = Array.from(input);
     _quicksort(array, ranker);
     return array;
 }
 /** Sort an array using a ranker (defaults to sorting in ascending order) */
-export function sortArray(input, ranker = rankAscending) {
+export function sortArray(input, ranker = rankAsc) {
     const output = Array.from(input);
     return _quicksort(output, ranker) ? output : input;
 }
@@ -144,24 +144,24 @@ export function sortArray(input, ranker = rankAscending) {
  * Sort an iterable set of entries (defaults to sorting by key in ascending order).
  * - Always returns an array
  */
-export function sortEntries(input, ranker = rankEntryKeyAsc) {
+export function sortEntries(input, ranker = rankKeyAsc) {
     const array = Array.from(input);
     _quicksort(array, ranker);
     return array;
 }
 /** Sort a map-like object using a ranker (defaults to sorting by key in ascending order). */
-export function sortObject(input, ranker = rankEntryKeyAsc) {
+export function sortObject(input, ranker = rankKeyAsc) {
     const array = Object.entries(input);
     return _quicksort(array, ranker) ? Object.fromEntries(array) : input;
 }
 /** Sort a map using a ranker (defaults to sorting by key in ascending order). */
-export function sortMap(input, ranker = rankEntryKeyAsc) {
+export function sortMap(input, ranker = rankKeyAsc) {
     const array = Array.from(input);
     return _quicksort(array, ranker) ? new Map(array) : input;
 }
 /** Derive a value and match it against a target value. */
 export class TransformRanker {
-    constructor(transformer, ranker = rankAscending) {
+    constructor(transformer, ranker = rankAsc) {
         this._transformer = transformer;
         this._ranker = ranker;
     }

package/util/template.js

@@ -83,7 +83,7 @@ const matchInternal = (template, target) => {
         const stopIndex = !post ? Infinity : target.indexOf(post, startIndex);
         if (stopIndex < 0)
             return undefined; // Target doesn't match template because chunk post wasn't found.
-        const value = target.substring(startIndex, stopIndex);
+        const value = target.slice(startIndex, stopIndex);
         if (!value.length)
             return undefined; // Target doesn't match template because chunk value was missing.
         values[name] = value;