shelving 1.86.3 → 1.86.5

package/constraint/FilterConstraint.d.ts

@@ -16,7 +16,7 @@ export type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
-export type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
+export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<Nullish<FilterProps<T> | FilterConstraint<T>>>;
 /**
  * Filter: filters a list of data.
  *
@@ -34,5 +34,5 @@ export declare class FilterConstraint<T extends Data = Data> implements Constrai
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Get the separate filters generated from a list of filters. */
-export declare function getFilters<T extends Data>(filters: FilterList<T>): Iterable<FilterConstraint<T>>;
+/** Turn `FilterList` into a list of `FilterConstraint` instances. */
+export declare function getFilters<T extends Data>(list: FilterList<T> | FilterList<T>[]): Iterable<FilterConstraint<T>>;

package/constraint/FilterConstraint.js

@@ -79,17 +79,18 @@ export class FilterConstraint {
         return `"${this.filterKey}":${JSON.stringify(this.value)}`;
     }
 }
-/** Get the separate filters generated from a list of filters. */
-export function* getFilters(filters) {
-    if (filters instanceof FilterConstraint) {
-        yield filters;
+/** Turn `FilterList` into a list of `FilterConstraint` instances. */
+export function* getFilters(list) {
+    if (list instanceof FilterConstraint) {
+        yield list;
     }
-    else if (isIterable(filters)) {
-        for (const filter of filters)
-            yield* getFilters(filter);
+    else if (isIterable(list)) {
+        for (const filter of list)
+            if (filter)
+                yield* getFilters(filter);
     }
-    else if (filters) {
-        for (const [key, value] of Object.entries(filters))
+    else {
+        for (const [key, value] of Object.entries(list))
             yield new FilterConstraint(key, value);
     }
 }

package/constraint/FilterConstraints.d.ts

@@ -8,14 +8,14 @@ import { Constraints } from "./Constraints.js";
  */
 export interface Filterable<T extends Data> extends Matchable<[T]> {
     /** Add a filter to this filterable. */
-    filter(...filters: FilterList<Partial<T>>[]): this;
+    filter(...filters: FilterList<T>[]): this;
     /** Match an item against the filters specified for this object. */
     match(item: T): boolean;
 }
 /** A set of filters. */
-export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<Partial<T>>> implements Filterable<T> {
-    constructor(...filters: FilterList<Partial<T>>[]);
-    filter(...filters: FilterList<Partial<T>>[]): this;
+export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<T>> implements Filterable<T> {
+    constructor(...filters: FilterList<T>[]);
+    filter(...filters: FilterList<T>[]): this;
     match(item: T): boolean;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/constraint/QueryConstraints.d.ts

@@ -31,11 +31,11 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<Partial<T>> | FilterConstraints<T>, sorts?: SortList<Partial<T>> | SortConstraints<T>, limit?: number | null);
-    filter(...filters: FilterList<Partial<T>>[]): this;
+    constructor(filters?: FilterList<T> | FilterConstraints<T>, sorts?: SortList<T> | SortConstraints<T>, limit?: number | null);
+    filter(...filters: FilterList<T>[]): this;
     get unfilter(): this;
     match(item: T): boolean;
-    sort(...sorts: SortList<Partial<T>>[]): this;
+    sort(...sorts: SortList<T>[]): this;
     get unsort(): this;
     rank(left: T, right: T): number;
     after(item: T): this;

package/constraint/SortConstraint.d.ts

@@ -10,7 +10,7 @@ export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
 export type SortDirection = "ASC" | "DESC";
 /** List of sorts in a flexible format. */
-export type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
+export type SortList<T extends Data> = SortKey<T> | SortConstraint<T> | Iterable<Nullish<SortKey<T> | SortConstraint<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly key: string;
@@ -21,5 +21,5 @@ export declare class SortConstraint<T extends Data = Data> implements Constraint
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Get the separate sorts generated from a list of sorts. */
-export declare function getSorts<T extends Data>(sorts: SortList<T>): Iterable<SortConstraint<T>>;
+/** Turn `SortList` into array of list of `SortConstraint` instances. */
+export declare function getSorts<T extends Data>(list: SortList<T> | SortList<T>[]): Iterable<SortConstraint<T>>;

package/constraint/SortConstraint.js

@@ -24,16 +24,17 @@ export class SortConstraint {
         return this.sortKey;
     }
 }
-/** Get the separate sorts generated from a list of sorts. */
-export function* getSorts(sorts) {
-    if (typeof sorts === "string") {
-        yield new SortConstraint(sorts);
-    }
-    else if (sorts instanceof SortConstraint) {
-        yield sorts;
-    }
-    else if (sorts) {
-        for (const sort of sorts)
-            yield* getSorts(sort);
+/** Turn `SortList` into array of list of `SortConstraint` instances. */
+export function* getSorts(list) {
+    if (typeof list === "string") {
+        yield new SortConstraint(list);
+    }
+    else if (list instanceof SortConstraint) {
+        yield list;
+    }
+    else {
+        for (const sort of list)
+            if (sort)
+                yield* getSorts(sort);
     }
 }

package/constraint/SortConstraints.d.ts

@@ -8,12 +8,12 @@ import { SortConstraint, SortList } from "./SortConstraint.js";
  */
 export interface Sortable<T extends Data> extends Rankable<T> {
     /** Add one or more sorts to this sortable. */
-    sort(...keys: SortList<Partial<T>>[]): this;
+    sort(...keys: SortList<T>[]): this;
 }
 /** A set of sorts. */
-export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<Partial<T>>> implements Sortable<T> {
-    constructor(...sorts: SortList<Partial<T>>[]);
-    sort(...sorts: SortList<Partial<T>>[]): this;
+export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<T>> implements Sortable<T> {
+    constructor(...sorts: SortList<T>[]);
+    sort(...sorts: SortList<T>[]): this;
     rank(left: T, right: T): number;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/db/Collection.d.ts

@@ -43,7 +43,7 @@ export declare class Collection<T extends Datas = Datas, K extends DataKey<T> =
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
-    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item(id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
     get(id: string): ItemValue<T[K]>;
@@ -57,7 +57,7 @@ export declare class AsyncCollection<T extends Datas = Datas, K extends DataKey<
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);
-    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item(id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
     get(id: string): Promise<ItemValue<T[K]>>;

package/db/Database.d.ts

@@ -45,7 +45,7 @@ export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
     collection<K extends DataKey<T>>(collection: K): Collection<T, K>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item<K extends DataKey<T>>(collection: K, id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
     get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
@@ -59,7 +59,7 @@ export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
     collection<K extends DataKey<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<T>>;
     get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;

package/db/Query.d.ts

@@ -73,7 +73,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> =
 export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
-    constructor(db: Database<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
+    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): ItemArray<T[K]>;
     get count(): number;
     get exists(): boolean;
@@ -89,7 +89,7 @@ export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataK
 export declare class AsyncQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
+    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): Promise<ItemArray<T[K]>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;

package/db/Query.js

@@ -1,4 +1,4 @@
-import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, isArrayMin, countArray } from "../util/array.js";
+import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, isArrayLength, countArray } from "../util/array.js";
 import { runSequence } from "../util/sequence.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 /** Reference to a set of items in a sync or async provider. */
@@ -68,7 +68,7 @@ export class AsyncQuery extends BaseQuery {
         return this.value.then(countArray);
     }
     get exists() {
-        return this.max(1).value.then(isArrayMin);
+        return this.max(1).value.then(isArrayLength);
     }
     get firstValue() {
         return this.max(1).value.then(getOptionalFirstItem);

package/markup/regexp.d.ts

@@ -41,7 +41,7 @@ export declare function getLineRegExp(content?: PossibleRegExp, end?: PossibleRe
  * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
  */
 export declare class WordRegExp extends RegExp {
-    constructor(pattern: string);
+    constructor(pattern: string, flags?: string);
     exec(input: string): RegExpExecArray | null;
     test(input: string): boolean;
 }

package/markup/regexp.js

@@ -26,8 +26,8 @@ export function getLineRegExp(content = LINE_REGEXP, end = LINE_END_REGEXP, star
  * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
  */
 export class WordRegExp extends RegExp {
-    constructor(pattern) {
-        super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`);
+    constructor(pattern, flags) {
+        super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`, flags);
     }
     exec(input) {
         var _a;

package/package.json

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

package/state/State.d.ts

@@ -1,3 +1,4 @@
+import type { Validatable } from "../util/validate.js";
 import { Dispatch, Handler, Stop } from "../util/function.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /** Any `State` instance. */
@@ -12,7 +13,7 @@ export type AnyState = State<any>;
  * - To set the state to be loading, use the `State.NOVALUE` constant or a `Promise` value.
  * - To set the state to an explicit value, use that value or another `State` instance with a value.
  * */
-export declare class State<T> implements AsyncIterable<T> {
+export declare class State<T> implements AsyncIterable<T>, Validatable<T> {
     /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
     static readonly NOVALUE: unique symbol;
     /** Deferred sequence this state uses to issue values as they change. */
@@ -30,7 +31,7 @@ export declare class State<T> implements AsyncIterable<T> {
     /** Is there a current value, or is it still loading. */
     get loading(): boolean;
     /** Set the value of the state. */
-    set(value: T): void;
+    set(next: T): void;
     /** Set the value of the state as values are pulled from a sequence. */
     through(sequence: AsyncIterable<T>): AsyncIterable<T>;
     /** Pull values from a source sequence until the returned stop function is called. */
@@ -38,6 +39,8 @@ export declare class State<T> implements AsyncIterable<T> {
     /** Push values to another state or callback to this state until the returned stop function is called. */
     to(target: Dispatch<[T]>, onError?: Handler): Stop;
     [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Validate data set on this state. */
+    validate(value: T): T;
 }
 /** Is an unknown value a `State` instance. */
 export declare const isState: <T extends AnyState>(v: unknown) => v is T;

package/state/State.js

@@ -28,8 +28,12 @@ export class State {
     }
     /** State is initiated with an initial state. */
     constructor(initial = State.NOVALUE, next = new DeferredSequence()) {
-        this._value = initial;
-        this._time = initial !== State.NOVALUE ? Date.now() : null;
+        this._value = State.NOVALUE;
+        this._time = null;
+        if (initial !== State.NOVALUE) {
+            this._value = this.validate(initial);
+            this._time = Date.now();
+        }
         this.next = next;
     }
     /** Is there a current value, or is it still loading. */
@@ -37,7 +41,8 @@ export class State {
         return this._value === State.NOVALUE;
     }
     /** Set the value of the state. */
-    set(value) {
+    set(next) {
+        const value = this.validate(next);
         if (value !== this._value) {
             this._value = value;
             this._time = Date.now();
@@ -67,6 +72,10 @@ export class State {
             yield this.value;
         yield* this.next;
     }
+    /** Validate data set on this state. */
+    validate(value) {
+        return value;
+    }
 }
 /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
 State.NOVALUE = Symbol("shelving/State.NOVALUE");

package/util/array.d.ts

@@ -60,20 +60,32 @@ export declare function limitArray<T>(items: Iterable<T>, limit: number): Immuta
 /** Count the items in an array. */
 export declare function countArray<T>(arr: ImmutableArray<T>): number;
 /** Does an array have the specified minimum length.  */
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min?: 1): arr is [T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 2): arr is [T, T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 3): arr is [T, T, T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: 4): arr is [T, T, T, T, ...T[]];
-export declare function isArrayMin<T>(arr: ImmutableArray<T>, min: number): boolean;
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): arr is readonly [T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): arr is readonly [T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): arr is readonly [T, T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): arr is readonly [T, T, T, T];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): arr is readonly [T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): arr is readonly [T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): arr is readonly [T, T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): arr is readonly [T, T, T, T, ...T[]];
+export declare function isArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): boolean;
 /** Assert that a value has a specific length (or length is in a specific range). */
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min?: 1): asserts arr is [T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 2): asserts arr is [T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 3): asserts arr is [T, T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: 4): asserts arr is [T, T, T, T, ...T[]];
-export declare function assertArrayMin<T>(arr: ImmutableArray<T> | unknown, min: number): asserts arr is ImmutableArray<T>;
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): asserts arr is readonly [T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): asserts arr is readonly [T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): asserts arr is readonly [T, T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): asserts arr is readonly [T, T, T, T];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min?: 1, max?: number): asserts arr is readonly [T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 2, max?: number): asserts arr is readonly [T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 3, max?: number): asserts arr is readonly [T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 4, max?: number): asserts arr is readonly [T, T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: number, max?: number): asserts arr is ImmutableArray<T>;
 /** Get an array if it has the specified minimum length.  */
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min?: 1): [T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 2): [T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 3): [T, T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: 4): [T, T, T, T, ...T[]];
-export declare function getArrayMin<T>(arr: ImmutableArray<T>, min: number): ImmutableArray<T>;
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): readonly [T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): readonly [T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): readonly [T, T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): readonly [T, T, T, T];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): readonly [T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): readonly [T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): readonly [T, T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): readonly [T, T, T, T, ...T[]];
+export declare function getArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): ImmutableArray<T>;

package/util/array.js

@@ -1,6 +1,7 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { filterItems, omitItems, pickItems } from "./iterate.js";
+import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
 export const isArray = (v) => Array.isArray(v);
 /** Assert that a value is an array. */
@@ -137,14 +138,14 @@ export function limitArray(items, limit) {
 export function countArray(arr) {
     return arr.length;
 }
-export function isArrayMin(arr, min = 1) {
-    return arr.length >= min;
+export function isArrayLength(arr, min = 1, max = Infinity) {
+    return arr.length >= min && arr.length <= max;
 }
-export function assertArrayMin(arr, min = 1) {
-    if (!isArray(arr) || !isArrayMin(arr, min))
-        throw new AssertionError(`Must be array with minimum length ${min}`, arr);
+export function assertArrayLength(arr, min = 1, max = Infinity) {
+    if (!isArray(arr) || !isArrayLength(arr, min, max))
+        throw new AssertionError(`Must be array with length ${formatRange(min, max)}`, arr);
 }
-export function getArrayMin(arr, min = 1) {
-    assertArrayMin(arr, min);
+export function getArrayLength(arr, min = 1, max = Infinity) {
+    assertArrayLength(arr, min, max);
     return arr;
 }

package/util/number.d.ts

@@ -70,6 +70,8 @@ export declare function boundNumber(num: number, min: number, max: number): numb
 export declare function wrapNumber(num: number, min: number, max: number): number;
 /** Format a number (based on the user's browser language settings). */
 export declare function formatNumber(num: number, precision?: number | null): string;
+/** Format a number range (based on the user's browser language settings). */
+export declare function formatRange(min: number, max: number, precision?: number | null): string;
 /** Format a number with a short suffix, e.g. `1,000 kg` */
 export declare const formatQuantity: (num: number, abbr: string, precision?: number | null) => string;
 /** Format a number with a longer full-word suffix. */

package/util/number.js

@@ -110,10 +110,16 @@ export function wrapNumber(num, min, max) {
 }
 /** Format a number (based on the user's browser language settings). */
 export function formatNumber(num, precision = null) {
+    if (Number.isNaN(num))
+        return "None";
     if (!Number.isFinite(num))
-        return Number.isNaN(num) ? "None" : "Infinity";
+        return "∞";
     return new Intl.NumberFormat(undefined, { minimumFractionDigits: precision !== null && precision !== void 0 ? precision : undefined, maximumFractionDigits: precision !== null && precision !== void 0 ? precision : 20 }).format(num);
 }
+/** Format a number range (based on the user's browser language settings). */
+export function formatRange(min, max, precision = null) {
+    return `${formatNumber(min, precision)}–${formatNumber(max, precision)}`;
+}
 /** Format a number with a short suffix, e.g. `1,000 kg` */
 export const formatQuantity = (num, abbr, precision) => `${formatNumber(num, precision)}${NNBSP}${abbr}`;
 /** Format a number with a longer full-word suffix. */

package/util/regexp.d.ts

@@ -6,16 +6,6 @@ export declare const ALWAYS_REGEXP: RegExp;
 export declare const NEVER_REGEXP: RegExp;
 /** Things that can be convert to a regular expression. */
 export type PossibleRegExp = string | RegExp;
-/** Is an unknown value a `RegExp` instance? */
-export declare const isRegExp: <T extends RegExp>(v: unknown) => v is T;
-/** Assert that an unknown value is a `RegExp` instance. */
-export declare function assertRegExp<T extends RegExp>(v: T | unknown): asserts v is T;
-/** Convert a string to a regular expression that matches that string. */
-export declare const getRegExp: (pattern: PossibleRegExp, flags?: string) => RegExp;
-/** Convert a regular expression to its string source. */
-export declare const getRegExpSource: (regexp: PossibleRegExp) => string;
-/** Escape special characters in a string regular expression. */
-export declare const escapeRegExp: (pattern: string) => string;
 /** Set of named match groups from a regular expression. */
 export type NamedRegExpData = {
     [named: string]: string;
@@ -28,6 +18,19 @@ export interface NamedRegExpArray<T extends NamedRegExpData = NamedRegExpData> e
 export interface NamedRegExp<T extends NamedRegExpData = NamedRegExpData> extends RegExp {
     exec(input: string): NamedRegExpArray<T> | null;
 }
+/** Is an unknown value a `RegExp` instance? */
+export declare const isRegExp: <T extends RegExp>(v: unknown) => v is T;
+/** Assert that an unknown value is a `RegExp` instance. */
+export declare function assertRegExp<T extends RegExp>(v: T | unknown): asserts v is T;
+/** Convert a string to a regular expression that matches that string. */
+export declare function getRegExp<T extends string>(pattern: `(?<${T}>${string})`, flags?: string): NamedRegExp<{
+    [K in T]: string;
+}>;
+export declare function getRegExp(pattern: PossibleRegExp, flags?: string): RegExp;
+/** Convert a regular expression to its string source. */
+export declare const getRegExpSource: (regexp: PossibleRegExp) => string;
+/** Escape special characters in a string regular expression. */
+export declare const escapeRegExp: (pattern: string) => string;
 /** Create regular expression that matches any of a list of other expressions. */
 export declare function getAnyRegExp(patterns: Iterable<PossibleRegExp> & NotString, flags?: string): RegExp;
 /** Create regular expression that matches all of a list of other expressions. */

package/util/regexp.js

@@ -11,8 +11,9 @@ export function assertRegExp(v) {
     if (!(v instanceof RegExp))
         throw new AssertionError("Must be regular expression", v);
 }
-/** Convert a string to a regular expression that matches that string. */
-export const getRegExp = (pattern, flags) => (typeof pattern === "string" ? new RegExp(pattern, flags) : pattern);
+export function getRegExp(pattern, flags) {
+    return typeof pattern === "string" ? new RegExp(pattern, flags) : pattern;
+}
 /** Convert a regular expression to its string source. */
 export const getRegExpSource = (regexp) => (typeof regexp === "string" ? regexp : regexp.source);
 /** Escape special characters in a string regular expression. */

package/util/string.d.ts

@@ -27,6 +27,12 @@ export declare function assertString(value: unknown): asserts value is string;
  * - Everything else returns `"Unknown"`
  */
 export declare function getString(value: unknown): string;
+/** Does a string have the specified minimum length.  */
+export declare const isStringLength: (str: string, min?: number, max?: number) => boolean;
+/** Assert that a value has a specific length (or length is in a specific range). */
+export declare function assertStringLength(str: string | unknown, min?: number, max?: number): asserts str is string;
+/** Get a string if it has the specified minimum length.  */
+export declare function getStringLength(arr: string, min?: number, max?: number): string;
 /** Concatenate an iterable set of strings together. */
 export declare const joinStrings: (strs: Iterable<string> & NotString, joiner?: string) => string;
 /**
@@ -89,13 +95,17 @@ export declare function limitString(str: string, maxLength: number, append?: str
  * Divide a string into parts based on a separator.
  * - Like `String.prototype.split()` but with more useful arguments.
  * - Excess segments in `String.prototype.split()` is counterintuitive because further parts are thrown away.
- * - Excess segments in `splitString()` are concatenated onto the last segment (set `maxSegments` to `null` if you want infinite segments).
+ * - Excess segments in `splitString()` are concatenated onto the last segment (set `max` to `null` if you want infinite segments).
  *
- * @throws AssertionError if `minSegments` isn't met.
+ * @throws AssertionError if `min` isn't met.
  * @throws AssertionError if any of the segments are empty.
  */
-export declare function splitString(str: string, separator: string, minSegments: 1, maxSegments?: number): readonly [string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 2, maxSegments?: number): readonly [string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 3, maxSegments?: number): readonly [string, string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments: 4, maxSegments?: number): readonly [string, string, string, string, ...string[]];
-export declare function splitString(str: string, separator: string, minSegments?: number, maxSegments?: number | null): ImmutableArray<string>;
+export declare function splitString(str: string, separator: string, min: 1, max: 1): readonly [string];
+export declare function splitString(str: string, separator: string, min: 2, max: 2): readonly [string, string];
+export declare function splitString(str: string, separator: string, min: 3, max: 3): readonly [string, string, string];
+export declare function splitString(str: string, separator: string, min: 4, max: 4): readonly [string, string, string, string];
+export declare function splitString(str: string, separator: string, min: 1, max?: number): readonly [string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 2, max?: number): readonly [string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 3, max?: number): readonly [string, string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min: 4, max?: number): readonly [string, string, string, string, ...string[]];
+export declare function splitString(str: string, separator: string, min?: number, max?: number): ImmutableArray<string>;

package/util/string.js

@@ -3,7 +3,7 @@ import { AssertionError } from "../error/AssertionError.js";
 import { formatDate, isDate } from "./date.js";
 import { formatObject, isObject } from "./object.js";
 import { getArray, isArray } from "./array.js";
-import { formatNumber, isBetween } from "./number.js";
+import { formatNumber, formatRange, isBetween } from "./number.js";
 /** Is a value a string? */
 export const isString = (v) => typeof v === "string";
 /** Assert that a value is a string. */
@@ -45,6 +45,18 @@ export function getString(value) {
         return formatObject(value);
     return "Unknown";
 }
+/** Does a string have the specified minimum length.  */
+export const isStringLength = (str, min = 1, max = Infinity) => str.length >= min && str.length <= max;
+/** Assert that a value has a specific length (or length is in a specific range). */
+export function assertStringLength(str, min = 1, max = Infinity) {
+    if (!isString(str) || !isStringLength(str, min, max))
+        throw new AssertionError(`Must be string with length ${formatRange(min, max)}`, str);
+}
+/** Get a string if it has the specified minimum length.  */
+export function getStringLength(arr, min = 1, max = Infinity) {
+    assertStringLength(arr, min, max);
+    return arr;
+}
 /** Concatenate an iterable set of strings together. */
 export const joinStrings = (strs, joiner = "") => getArray(strs).join(joiner);
 /**
@@ -133,11 +145,11 @@ export function limitString(str, maxLength, append = "…") {
     const lastSpace = str.lastIndexOf(" ", maxLength);
     return `${str.slice(0, lastSpace > 0 ? lastSpace : maxLength).trimEnd()}${append}`;
 }
-export function splitString(str, separator, minSegments = 0, maxSegments = minSegments) {
+export function splitString(str, separator, min = 1, max = Infinity) {
     const segments = str.split(separator);
-    if (typeof maxSegments === "number" && segments.length > maxSegments)
-        segments.splice(maxSegments - 1, segments.length, segments.slice(maxSegments - 1).join(separator));
-    if (segments.length < minSegments || !segments.every(Boolean))
-        throw new AssertionError(`Must be string with ${minSegments} non-empty segments separated by "${separator}"`, str);
+    if (segments.length > max)
+        segments.splice(max - 1, segments.length, segments.slice(max - 1).join(separator));
+    if (segments.length < min || !segments.every(Boolean))
+        throw new AssertionError(`Must be string with ${formatRange(min, max)} non-empty segments separated by "${separator}"`, str);
     return segments;
 }