shelving 1.120.0 → 1.121.1

package/{change → db}/Change.d.ts

@@ -1,8 +1,9 @@
-import type { AsyncProvider, Provider } from "../db/Provider.js";
+import type { AsyncProvider, Provider } from "./Provider.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
 import type { Updates } from "../util/update.js";
+import { type Optional } from "../util/optional.js";
 /** A change to a database. */
 export interface Change {
     readonly action: string;
@@ -66,5 +67,9 @@ export type DatabaseChange<T extends Database> = ItemAddChange<T, DataKey<T>> |
 export type DatabaseChanges<T extends Database> = ImmutableArray<DatabaseChange<T>>;
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export declare function writeChange<T extends Database>(provider: Provider<T>, change: DatabaseChange<T>): DatabaseChange<T>;
+/** Write a set of changes to a synchronous provider. */
+export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Optional<DatabaseChange<T>>[]): DatabaseChanges<T>;
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export declare function writeAsyncChange<T extends Database>(provider: AsyncProvider<T>, change: DatabaseChange<T>): Promise<DatabaseChange<T>>;
+/** Write a set of changes to an asynchronous provider. */
+export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Optional<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;

package/{change → db}/Change.js

@@ -1,3 +1,4 @@
+import { notOptional } from "../util/optional.js";
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
 export function writeChange(provider, change) {
     const { action, collection, id, query } = change;
@@ -23,6 +24,10 @@ export function writeChange(provider, change) {
     }
     return change;
 }
+/** Write a set of changes to a synchronous provider. */
+export function writeChanges(provider, ...changes) {
+    return changes.filter(notOptional).map(change => writeChange(provider, change));
+}
 /** Write a single change to an asynchronous provider and return the change that was written. */
 export async function writeAsyncChange(provider, change) {
     const { collection, action, id, query } = change;
@@ -48,3 +53,7 @@ export async function writeAsyncChange(provider, change) {
     }
     return change;
 }
+/** Write a set of changes to an asynchronous provider. */
+export function writeAsyncChanges(provider, ...changes) {
+    return Promise.all(changes.filter(notOptional).map(change => writeAsyncChange(provider, change)));
+}

package/db/{LoggedProvider.d.ts → ChangesProvider.d.ts}

@@ -1,13 +1,13 @@
-import type { DatabaseChange, DatabaseChanges } from "../change/Change.js";
+import type { DatabaseChange, DatabaseChanges } from "./Change.js";
 import type { MutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
 import type { Updates } from "../util/update.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
-/** Synchronous provider that keeps a log of any written changes to its `.written` property. */
-export declare class LoggedProvider<T extends Database> extends ThroughProvider<T> {
-    get written(): DatabaseChanges<T>;
-    readonly _written: MutableArray<DatabaseChange<T>>;
+/** Synchronous provider that keeps a log of any written changes to its `.changes` property. */
+export declare class ChangesProvider<T extends Database> extends ThroughProvider<T> {
+    get changes(): DatabaseChanges<T>;
+    readonly _changes: MutableArray<DatabaseChange<T>>;
     addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
     setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
     updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;

package/db/{LoggedProvider.js → ChangesProvider.js}

@@ -1,38 +1,38 @@
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
-/** Synchronous provider that keeps a log of any written changes to its `.written` property. */
-export class LoggedProvider extends ThroughProvider {
-    get written() {
-        return this._written;
+/** Synchronous provider that keeps a log of any written changes to its `.changes` property. */
+export class ChangesProvider extends ThroughProvider {
+    get changes() {
+        return this._changes;
     }
-    _written = [];
+    _changes = [];
     addItem(collection, data) {
         const id = super.addItem(collection, data);
-        this._written.push({ action: "set", collection, id, data });
+        this._changes.push({ action: "set", collection, id, data });
         return id;
     }
     setItem(collection, id, data) {
         super.setItem(collection, id, data);
-        this._written.push({ action: "set", collection, id, data });
+        this._changes.push({ action: "set", collection, id, data });
     }
     updateItem(collection, id, updates) {
         super.updateItem(collection, id, updates);
-        this._written.push({ action: "update", collection, id, updates });
+        this._changes.push({ action: "update", collection, id, updates });
     }
     deleteItem(collection, id) {
         super.deleteItem(collection, id);
-        this._written.push({ action: "delete", collection, id });
+        this._changes.push({ action: "delete", collection, id });
     }
     setQuery(collection, query, data) {
         super.setQuery(collection, query, data);
-        this._written.push({ action: "set", collection, query, data });
+        this._changes.push({ action: "set", collection, query, data });
     }
     updateQuery(collection, query, updates) {
         super.updateQuery(collection, query, updates);
-        this._written.push({ action: "update", collection, query, updates });
+        this._changes.push({ action: "update", collection, query, updates });
     }
     deleteQuery(collection, query) {
         super.deleteQuery(collection, query);
-        this._written.push({ action: "delete", collection, query });
+        this._changes.push({ action: "delete", collection, query });
     }
 }
 /** Asynchronous provider that keeps a log of any written changes to its `.written` property. */

package/db/index.d.ts

@@ -3,7 +3,8 @@ export * from "./QueryStore.js";
 export * from "./Provider.js";
 export * from "./ThroughProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ChangesProvider.js";
 export * from "./DebugProvider.js";
-export * from "./LoggedProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
+export * from "./Change.js";

package/db/index.js

@@ -5,7 +5,9 @@ export * from "./QueryStore.js";
 export * from "./Provider.js";
 export * from "./ThroughProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ChangesProvider.js";
 export * from "./DebugProvider.js";
-export * from "./LoggedProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
+// Util.
+export * from "./Change.js";

package/index.d.ts

@@ -4,7 +4,6 @@
  * - Modules that are for internal use, like `shelving/test`
  */
 export * from "./api/index.js";
-export * from "./change/index.js";
 export * from "./db/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";

package/index.js

@@ -4,7 +4,6 @@
  * - Modules that are for internal use, like `shelving/test`
  */
 export * from "./api/index.js";
-export * from "./change/index.js";
 export * from "./db/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.120.0",
+	"version": "1.121.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -22,7 +22,6 @@
 	"exports": {
 		".": "./index.js",
 		"./api": "./api/index.js",
-		"./change": "./change/index.js",
 		"./db": "./db/index.js",
 		"./error": "./error/index.js",
 		"./feedback": "./feedback/index.js",
@@ -31,7 +30,6 @@
 		"./firestore/server": "./firestore/server/index.js",
 		"./iterate": "./iterate/index.js",
 		"./markup": "./markup/index.js",
-		"./provider": "./provider/index.js",
 		"./react": "./react/index.js",
 		"./schema": "./schema/index.js",
 		"./sequence": "./sequence/index.js",

package/util/array.d.ts

@@ -13,11 +13,11 @@ export type ArrayItem<T extends ImmutableArray> = T[number];
 /** Things that can be converted to arrays. */
 export type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Is an unknown value an array? */
-export declare const isArray: (value: unknown) => value is ImmutableArray<unknown>;
+export declare function isArray(value: unknown): value is ImmutableArray;
 /** Assert that an unknown value is an array. */
 export declare function assertArray<T>(arr: unknown): asserts arr is ImmutableArray<T>;
 /** Is an unknown value an item in a specified array? */
-export declare const isArrayItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
+export declare function isArrayItem<T>(arr: ImmutableArray<T>, item: unknown): item is T;
 /** Assert that an unknown value is an item in a specified array. */
 export declare function assertArrayItem<T>(arr: ImmutableArray<T>, item: unknown): asserts item is T;
 /** Convert an iterable to an array (if its not already an array). */
@@ -28,8 +28,6 @@ export declare function withArrayItems<T>(arr: ImmutableArray<T>, ...items: T[])
 export declare function pickArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...pick: T[]): ImmutableArray<T>;
 /** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
 export declare function omitArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...omit: T[]): ImmutableArray<T>;
-/** Clear an array (immutably) and return a new empty array (or the same array if no changes were made). */
-export declare const clearArray: <T>(input: ImmutableArray<T>) => ImmutableArray<T>;
 /** Toggle an item in and out of an array (immutably) and return a new array with or without the specified items (or the same array if no changes were made). */
 export declare function toggleArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /** Get the first item from an array or iterable, or `undefined` if it didn't exist. */

package/util/array.js

@@ -3,14 +3,18 @@ import { ValueError } from "../error/ValueError.js";
 import { omitItems, pickItems } from "./iterate.js";
 import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
-export const isArray = (value) => Array.isArray(value);
+export function isArray(value) {
+    return Array.isArray(value);
+}
 /** Assert that an unknown value is an array. */
 export function assertArray(arr) {
     if (!isArray(arr))
         throw new ValueError(`Must be array`, arr);
 }
 /** Is an unknown value an item in a specified array? */
-export const isArrayItem = (arr, item) => arr.includes(item);
+export function isArrayItem(arr, item) {
+    return arr.includes(item);
+}
 /** Assert that an unknown value is an item in a specified array. */
 export function assertArrayItem(arr, item) {
     if (!isArrayItem(arr, item))
@@ -38,8 +42,6 @@ export function omitArrayItems(input, ...omit) {
     const output = Array.from(omitItems(input, ...omit));
     return isArray(input) && output.length === input.length ? input : output;
 }
-/** Clear an array (immutably) and return a new empty array (or the same array if no changes were made). */
-export const clearArray = (input) => (input.length ? [] : input);
 /** Toggle an item in and out of an array (immutably) and return a new array with or without the specified items (or the same array if no changes were made). */
 export function toggleArrayItems(input, ...items) {
     const extras = items.filter(_doesNotInclude, input);

package/util/async.d.ts

@@ -1,9 +1,9 @@
 import type { ValueCallback } from "./callback.js";
 import type { Report } from "./error.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
-export declare const isAsync: <T>(value: T | PromiseLike<T>) => value is PromiseLike<T>;
+export declare function isAsync<T>(value: PromiseLike<T> | T): value is PromiseLike<T>;
 /** Is a value a synchronous value. */
-export declare const notAsync: <T>(value: T | PromiseLike<T>) => value is T;
+export declare function notAsync<T>(value: PromiseLike<T> | T): value is T;
 /**
  * Throw the value if it's an async (promised) value.
  * @returns Synchronous (not promised) value.

package/util/async.js

@@ -1,8 +1,12 @@
 import { ValueError } from "../error/ValueError.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
-export const isAsync = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+export function isAsync(value) {
+    return typeof value === "object" && value !== null && typeof value.then === "function";
+}
 /** Is a value a synchronous value. */
-export const notAsync = (value) => !isAsync(value);
+export function notAsync(value) {
+    return !isAsync(value);
+}
 /**
  * Throw the value if it's an async (promised) value.
  * @returns Synchronous (not promised) value.

package/util/boolean.d.ts

@@ -1,13 +1,13 @@
 /** Is a value a boolean? */
-export declare const isBoolean: (value: unknown) => value is boolean;
+export declare function isBoolean(value: unknown): value is boolean;
 /** Is a value true? */
-export declare const isTrue: (value: unknown) => value is true;
+export declare function isTrue(value: unknown): value is true;
 /** Is a value false? */
-export declare const isFalse: (value: unknown) => value is false;
+export declare function isFalse(value: unknown): value is false;
 /** Is a value truthy? */
-export declare const isTruthy: (value: unknown) => boolean;
+export declare function isTruthy(value: unknown): boolean;
 /** Is a value falsey? */
-export declare const isFalsey: (value: unknown) => boolean;
+export declare function isFalsey(value: unknown): boolean;
 /** Assert that a value is a boolean. */
 export declare function assertBoolean(value: unknown): asserts value is boolean;
 /** Assert that a value is true. */

package/util/boolean.js

@@ -1,14 +1,24 @@
 import { ValueError } from "../error/ValueError.js";
 /** Is a value a boolean? */
-export const isBoolean = (value) => typeof value === "boolean";
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
 /** Is a value true? */
-export const isTrue = (value) => value === true;
+export function isTrue(value) {
+    return value === true;
+}
 /** Is a value false? */
-export const isFalse = (value) => value === false;
+export function isFalse(value) {
+    return value === false;
+}
 /** Is a value truthy? */
-export const isTruthy = (value) => !!value;
+export function isTruthy(value) {
+    return !!value;
+}
 /** Is a value falsey? */
-export const isFalsey = (value) => !value;
+export function isFalsey(value) {
+    return !value;
+}
 /** Assert that a value is a boolean. */
 export function assertBoolean(value) {
     if (typeof value !== "boolean")

package/util/class.d.ts

@@ -6,8 +6,8 @@ export type AnyConstructor = new (...args: any) => any;
 /** Class prototype that can be used with `instanceof`. */
 export type Class<T> = new (...args: any) => T;
 /** Is a given value a class constructor? */
-export declare const isConstructor: (value: unknown) => value is AnyConstructor;
+export declare function isConstructor(value: unknown): value is AnyConstructor;
 /** Is a value an instance of a class? */
-export declare const isInstance: <T>(value: unknown, type: Class<T>) => value is T;
+export declare function isInstance<T>(value: unknown, type: Class<T>): value is T;
 /** Assert that a value is an instance of something. */
 export declare function assertInstance<T>(value: unknown, type: Class<T>): asserts value is T;

package/util/class.js

@@ -1,9 +1,13 @@
 import { ValueError } from "../error/ValueError.js";
 import { debug } from "./debug.js";
 /** Is a given value a class constructor? */
-export const isConstructor = (value) => typeof value === "function" && value.toString().startsWith("class");
+export function isConstructor(value) {
+    return typeof value === "function" && value.toString().startsWith("class");
+}
 /** Is a value an instance of a class? */
-export const isInstance = (value, type) => value instanceof type;
+export function isInstance(value, type) {
+    return value instanceof type;
+}
 /** Assert that a value is an instance of something. */
 export function assertInstance(value, type) {
     if (!(value instanceof type))

package/util/color.d.ts

@@ -26,7 +26,7 @@ export declare class Color {
     toString(): string;
 }
 /** Is an unknown value a `Color` instance. */
-export declare const isColor: (value: unknown) => value is Color;
+export declare function isColor(value: unknown): value is Color;
 /** Assert that an unknown value is a `Color` instance. */
 export declare function assertColor(value: unknown): asserts value is Color;
 /** Convert a possible color to a `Color` instance or `undefined` */

package/util/color.js

@@ -58,10 +58,16 @@ export class Color {
         return this.rgba;
     }
 }
-const _parse = (hex) => parseInt(hex.padStart(2, "00"), 16);
-const _hex = (channel) => channel.toString(16).padStart(2, "00");
+function _parse(hex) {
+    return parseInt(hex.padStart(2, "00"), 16);
+}
+function _hex(channel) {
+    return channel.toString(16).padStart(2, "00");
+}
 /** Is an unknown value a `Color` instance. */
-export const isColor = (value) => value instanceof Color;
+export function isColor(value) {
+    return value instanceof Color;
+}
 /** Assert that an unknown value is a `Color` instance. */
 export function assertColor(value) {
     if (!isColor(value))

package/util/data.d.ts

@@ -44,7 +44,7 @@ export type LeafProp<T extends Data> = {
     readonly [K in DataKey<T>]: (T[K] extends Data ? LeafProp<T[K]> : readonly [null, T[K]]) extends infer E ? E extends readonly [infer KK, infer VV] ? readonly [KK extends string ? `${K}.${KK}` : K, VV] : never : never;
 }[DataKey<T>];
 /** Is an unknown value a data object? */
-export declare const isData: (value: unknown) => value is Data;
+export declare function isData(value: unknown): value is Data;
 /** Assert that an unknown value is a data object. */
 export declare function assertData(value: unknown): asserts value is Data;
 /** Is an unknown value the key for an own prop of a data object. */

package/util/data.js

@@ -2,7 +2,9 @@ import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
 import { isObject, isPlainObject } from "./object.js";
 /** Is an unknown value a data object? */
-export const isData = (value) => isPlainObject(value);
+export function isData(value) {
+    return isPlainObject(value);
+}
 /** Assert that an unknown value is a data object. */
 export function assertData(value) {
     if (!isPlainObject(value))

package/util/dictionary.d.ts

@@ -13,7 +13,7 @@ export type DictionaryValue<T extends ImmutableDictionary> = T[string];
 /** Something that can be converted to a dictionary object. */
 export type PossibleDictionary<T> = ImmutableDictionary<T> | Iterable<DictionaryItem<T>>;
 /** Is an unknown value a dictionary object? */
-export declare const isDictionary: (value: unknown) => value is ImmutableDictionary<unknown>;
+export declare function isDictionary(value: unknown): value is ImmutableDictionary;
 /** Assert that an unknown value is a dictionary object */
 export declare function assertDictionary(value: unknown): asserts value is ImmutableDictionary;
 /** turn a possible dictionary into a dictionary. */
@@ -22,7 +22,7 @@ export declare function getDictionary<T>(obj: PossibleDictionary<T>): ImmutableD
 export declare function getDictionaryItems<T>(obj: ImmutableDictionary<T>): readonly DictionaryItem<T>[];
 export declare function getDictionaryItems<T>(obj: PossibleDictionary<T>): Iterable<DictionaryItem<T>>;
 /** Is an unknown value the key for an own prop of a dictionary. */
-export declare const isDictionaryItem: <T>(obj: ImmutableDictionary<T>, key: unknown) => key is string;
+export declare function isDictionaryItem<T>(obj: ImmutableDictionary<T>, key: unknown): key is string;
 /** Assert that an unknown value is the key for an own prop of a dictionary. */
 export declare function assertDictionaryItem<T>(obj: ImmutableDictionary<T>, key: unknown): asserts key is string;
 /** Get an item in a map or throw an error if it doesn't exist. */

package/util/dictionary.js

@@ -3,7 +3,9 @@ import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
 import { deleteProps, isPlainObject, omitProps, pickProps, setProp, setProps, withProp, withProps } from "./object.js";
 /** Is an unknown value a dictionary object? */
-export const isDictionary = (value) => isPlainObject(value);
+export function isDictionary(value) {
+    return isPlainObject(value);
+}
 /** Assert that an unknown value is a dictionary object */
 export function assertDictionary(value) {
     if (!isDictionary(value))
@@ -17,7 +19,9 @@ export function getDictionaryItems(obj) {
     return isIterable(obj) ? obj : Object.entries(obj);
 }
 /** Is an unknown value the key for an own prop of a dictionary. */
-export const isDictionaryItem = (obj, key) => typeof key === "string" && Object.hasOwn(obj, key);
+export function isDictionaryItem(obj, key) {
+    return typeof key === "string" && Object.hasOwn(obj, key);
+}
 /** Assert that an unknown value is the key for an own prop of a dictionary. */
 export function assertDictionaryItem(obj, key) {
     if (!isDictionaryItem(obj, key))

package/util/dispose.d.ts

@@ -18,7 +18,7 @@ export interface Disposable {
 /** Safely dispose a disposable. */
 export declare function dispose(value: Disposable): void;
 /** Is an unknown value a disposable object? */
-export declare const isDisposable: (v: unknown) => v is Disposable;
+export declare function isDisposable(v: unknown): v is Disposable;
 /**
  * Version of `Map` that is disposable.
  * - If items are `Disposable` they are disposed when they're deleted from the map.

package/util/dispose.js

@@ -15,7 +15,9 @@ export function dispose(value) {
     }
 }
 /** Is an unknown value a disposable object? */
-export const isDisposable = (v) => isObject(v) && typeof v[Symbol.dispose] === "function";
+export function isDisposable(v) {
+    return isObject(v) && typeof v[Symbol.dispose] === "function";
+}
 /**
  * Version of `Map` that is disposable.
  * - If items are `Disposable` they are disposed when they're deleted from the map.

package/util/entry.d.ts

@@ -16,9 +16,9 @@ export type EntryObject<T extends Entry<PropertyKey, unknown>> = {
     readonly [E in T as E[0]]: E[1];
 };
 /** Extract the key from an object entry. */
-export declare const getEntryKey: <K, T>([k]: Entry<K, T>) => K;
+export declare function getEntryKey<K, T>([k]: Entry<K, T>): K;
 /** Extract the value from an object entry. */
-export declare const getEntryValue: <K, T>([, v]: Entry<K, T>) => T;
+export declare function getEntryValue<K, T>([, v]: Entry<K, T>): T;
 /** Yield the keys of an iterable set of entries. */
 export declare function getEntryKeys<K, T>(input: Iterable<Entry<K, T>>): Iterable<K>;
 /** Yield the values of an iterable set of entries. */

package/util/entry.js

@@ -2,9 +2,13 @@ import { isArray } from "./array.js";
 import { isIterable } from "./iterate.js";
 import { isSet } from "./set.js";
 /** Extract the key from an object entry. */
-export const getEntryKey = ([k]) => k;
+export function getEntryKey([k]) {
+    return k;
+}
 /** Extract the value from an object entry. */
-export const getEntryValue = ([, v]) => v;
+export function getEntryValue([, v]) {
+    return v;
+}
 /** Yield the keys of an iterable set of entries. */
 export function* getEntryKeys(input) {
     for (const [k] of input)

package/util/equal.d.ts

@@ -3,31 +3,31 @@ import type { ImmutableMap } from "./map.js";
 import type { Match } from "./match.js";
 import type { ImmutableObject } from "./object.js";
 /** Is unknown value `left` exactly equal to `right`? */
-export declare const isEqual: <T>(left: unknown, right: T) => left is T;
+export declare function isEqual<T>(left: unknown, right: T): left is T;
 /** Is unknown value `left` not exactly equal to `right`? */
-export declare const notEqual: <T, N>(left: T | N, right: N) => left is T;
+export declare function notEqual<T, N>(left: T | N, right: N): left is T;
 /** Is unknown value `left` less than `right`? */
-export declare const isLess: (left: unknown, right: unknown) => boolean;
+export declare function isLess(left: unknown, right: unknown): boolean;
 /** Is unknown value `left` less than or equal to `right`? */
-export declare const isEqualLess: (left: unknown, right: unknown) => boolean;
+export declare function isEqualLess(left: unknown, right: unknown): boolean;
 /** Is unknown value `left` greater than `right`? */
-export declare const isGreater: (left: unknown, right: unknown) => boolean;
+export declare function isGreater(left: unknown, right: unknown): boolean;
 /** Is unknown value `left` greater than or equal to `right`? */
-export declare const isEqualGreater: (left: unknown, right: unknown) => boolean;
+export declare function isEqualGreater(left: unknown, right: unknown): boolean;
 /**
  * Are two unknown values shallowly equal?
  * - If the values are both arrays/objects, see if the items/properties are **shallowly** equal with each other.
  */
-export declare const isShallowEqual: <T extends unknown>(left: unknown, right: T) => left is T;
+export declare function isShallowEqual<T extends unknown>(left: unknown, right: T): left is T;
 /** Are two unknown values not shallowly equal? */
-export declare const notShallowEqual: <T extends unknown>(left: unknown, right: T) => left is T;
+export declare function notShallowEqual<T extends unknown>(left: unknown, right: T): left is T;
 /**
  * Are two unknown values deeply equal?
  * - If the values are both arrays/objects, see if the items/properties are **deeply** equal with each other.
  */
-export declare const isDeepEqual: <T extends unknown>(left: unknown, right: T) => left is T;
+export declare function isDeepEqual<T extends unknown>(left: unknown, right: T): left is T;
 /** Are two unknown values not deeply equal? */
-export declare const notDeepEqual: <T extends unknown>(left: unknown, right: T) => left is T;
+export declare function notDeepEqual<T extends unknown>(left: unknown, right: T): left is T;
 /**
  * Are two maps equal (based on their items).
  */
@@ -41,13 +41,13 @@ export declare function isMapEqual<T extends ImmutableMap>(left: ImmutableMap, r
  */
 export declare function isArrayEqual<T extends ImmutableArray>(left: ImmutableArray, right: T, recursor?: Match): left is T;
 /** Is unknown value `left` in array `right`? */
-export declare const isInArray: <R>(left: unknown, right: ImmutableArray<R>) => left is R;
+export declare function isInArray<R>(left: unknown, right: ImmutableArray<R>): left is R;
 /** Is unknown value `left` not in array `right`? */
-export declare const notInArray: (left: unknown, right: ImmutableArray) => boolean;
+export declare function notInArray(left: unknown, right: ImmutableArray): boolean;
 /** Is unknown value `left` an array including `right`? */
-export declare const isArrayWith: <T>(left: unknown, right: T) => left is ImmutableArray<T>;
+export declare function isArrayWith<T>(left: unknown, right: T): left is ImmutableArray<T>;
 /** Is unknown value `left` not an array or does not include `right`? */
-export declare const notArrayWith: (left: unknown, right: unknown) => boolean;
+export declare function notArrayWith(left: unknown, right: unknown): boolean;
 /**
  * Are two objects equal based on their own props?
  * - `left` must have every property present in `right`
@@ -69,6 +69,6 @@ export declare function isObjectEqual<T extends ImmutableObject>(left: Immutable
  */
 export declare function isObjectMatch<L extends ImmutableObject, R extends ImmutableObject>(left: L | R, right: R, recursor?: Match): left is L & R;
 /** Is unknown value `left` an object with every prop from `right`? */
-export declare const isObjectWith: (left: unknown, right: ImmutableObject) => boolean;
+export declare function isObjectWith(left: unknown, right: ImmutableObject): boolean;
 /** Is unknown value `left` not an object or missing one or more props from `right`? */
-export declare const notObjectWith: (left: unknown, right: ImmutableObject) => boolean;
+export declare function notObjectWith(left: unknown, right: ImmutableObject): boolean;