shelving 1.134.1 → 1.136.0

package/iterate/InspectIterator.js

@@ -1,4 +1,5 @@
-import { ConflictError } from "../error/ConflictError.js";
+import { UnexpectedError } from "../error/UnexpectedError.js";
+import { getGetter } from "../util/class.js";
 import { ThroughIterator } from "./ThroughIterator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
@@ -20,21 +21,30 @@ export class InspectIterator extends ThroughIterator {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new ConflictError("Iteration not started");
+            throw new UnexpectedError("Iteration not started", {
+                iterator: this,
+                caller: getGetter(this, "first"),
+            });
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new ConflictError("Iteration not started");
+            throw new UnexpectedError("Iteration not started", {
+                iterator: this,
+                caller: getGetter(this, "last"),
+            });
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new ConflictError("Iteration not done");
+            throw new UnexpectedError("Iteration not done", {
+                iterator: this,
+                caller: getGetter(this, "returned"),
+            });
         return this._returned;
     }
     _returned = _NOVALUE;

package/markup/rule/link.js

@@ -1,4 +1,4 @@
-import { getOptionalLink } from "../../util/link.js";
+import { getLink } from "../../util/link.js";
 import { getRegExp } from "../../util/regexp.js";
 import { formatURL, getOptionalURL } from "../../util/url.js";
 import { renderMarkup } from "../render.js";
@@ -8,7 +8,7 @@ import { getMarkupRule } from "../util/rule.js";
 function renderLinkMarkupRule({ groups: { title, href: unsafeHref } }, options, key) {
     const { base, schemes, hosts, rel } = options;
     const url = getOptionalURL(unsafeHref, base);
-    const href = getOptionalLink(url, base, schemes, hosts);
+    const href = getLink(url, base, schemes, hosts);
     const children = title ? renderMarkup(title, options, "link") : url ? formatURL(url) : "";
     return {
         key,

package/package.json

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

package/react/createCacheContext.js

@@ -1,22 +1,21 @@
 import { createContext, createElement, useContext, useRef } from "react";
-import { ConflictError } from "../error/ConflictError.js";
+import { UnexpectedError } from "../error/UnexpectedError.js";
 /**
  * Create a cache context that can be provided to React elements and allows them to call `useCache()`
  * - Cache is a `Map` indexed by strings that can be used to store any value.
  */
 export function createCacheContext() {
     const context = createContext(undefined);
-    return {
-        useCache() {
-            const cache = useContext(context);
-            if (!cache)
-                throw new ConflictError("useCache() must be used inside <Cache>");
-            return cache;
-        },
-        CacheContext({ children }) {
-            // biome-ignore lint/suspicious/noAssignInExpressions: This is the most efficient way to do this.
-            const cache = (useRef().current ||= new Map());
-            return createElement(context.Provider, { children, value: cache });
-        },
+    const useCache = () => {
+        const cache = useContext(context);
+        if (!cache)
+            throw new UnexpectedError("useCache() must be used inside <Cache>", { caller: useCache });
+        return cache;
     };
+    const CacheContext = ({ children }) => {
+        // biome-ignore lint/suspicious/noAssignInExpressions: This is the most efficient way to do this.
+        const cache = (useRef().current ||= new Map());
+        return createElement(context.Provider, { children, value: cache });
+    };
+    return { useCache, CacheContext };
 }

package/react/createDataContext.js

@@ -2,7 +2,7 @@ import { CacheProvider } from "../db/CacheProvider.js";
 import { ItemStore } from "../db/ItemStore.js";
 import { QueryStore } from "../db/QueryStore.js";
 import { setMapItem } from "../util/map.js";
-import { getOptionalSource } from "../util/source.js";
+import { getSource } from "../util/source.js";
 import { createCacheContext } from "./createCacheContext.js";
 import { useStore } from "./useStore.js";
 /**
@@ -14,7 +14,7 @@ export function createDataContext(provider) {
     // biome-ignore lint/suspicious/noExplicitAny: The outer function enforces the type.
     const { CacheContext, useCache } = createCacheContext();
     // If this provider is backed by an in-memory cache, pass it to the `ItemStore` and `QueryStore` instances we create.
-    const memory = getOptionalSource(CacheProvider, provider)?.memory;
+    const memory = getSource(CacheProvider, provider)?.memory;
     return {
         useItem: (collection, id) => {
             const cache = useCache();

package/schema/AllowSchema.js

@@ -1,5 +1,5 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { getFirstItem } from "../util/array.js";
+import { requireFirstItem } from "../util/iterate.js";
 import { getMap, isMapItem } from "../util/map.js";
 import { getString } from "../util/string.js";
 import { Schema } from "./Schema.js";
@@ -8,7 +8,7 @@ export class AllowSchema extends Schema {
     allow;
     constructor(options) {
         const allow = getMap(options.allow);
-        const value = getFirstItem(allow.keys());
+        const value = requireFirstItem(allow.keys());
         super({ value, ...options });
         this.allow = allow;
     }

package/schema/DateSchema.d.ts

@@ -14,7 +14,7 @@ export declare class DateSchema extends Schema<string> {
     readonly min: Date | undefined;
     readonly max: Date | undefined;
     constructor({ min, max, title, value, ...options }: DateSchemaOptions);
-    validate(unsafeValue?: unknown): string;
+    validate(value?: unknown): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
 export declare const DATE: DateSchema;

package/schema/DateSchema.js

@@ -1,5 +1,5 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { formatDate, getOptionalDate, getYMD } from "../util/date.js";
+import { formatDate, getDate, requireYMD } from "../util/date.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
@@ -8,18 +8,18 @@ export class DateSchema extends Schema {
     max;
     constructor({ min, max, title = "Date", value = "now", ...options }) {
         super({ title, value, ...options });
-        this.min = getOptionalDate(min);
-        this.max = getOptionalDate(max);
+        this.min = getDate(min);
+        this.max = getDate(max);
     }
-    validate(unsafeValue = this.value) {
-        const optionalDate = getOptionalDate(unsafeValue);
-        if (!optionalDate)
-            throw new ValueFeedback(unsafeValue ? "Invalid date" : "Required", unsafeValue);
-        if (this.min && optionalDate < this.min)
-            throw new ValueFeedback(`Minimum ${formatDate(this.min)}`, optionalDate);
-        if (this.max && optionalDate > this.max)
-            throw new ValueFeedback(`Maximum ${formatDate(this.max)}`, optionalDate);
-        return getYMD(optionalDate);
+    validate(value = this.value) {
+        const date = getDate(value);
+        if (!date)
+            throw new ValueFeedback(value ? "Invalid date" : "Required", value);
+        if (this.min && date < this.min)
+            throw new ValueFeedback(`Minimum ${formatDate(this.min)}`, date);
+        if (this.max && date > this.max)
+            throw new ValueFeedback(`Maximum ${formatDate(this.max)}`, date);
+        return requireYMD(date);
     }
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/FileSchema.js

@@ -1,5 +1,5 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { getOptionalFileExtension } from "../util/file.js";
+import { getFileExtension } from "../util/file.js";
 import { isProp } from "../util/object.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
@@ -12,7 +12,7 @@ export class FileSchema extends StringSchema {
     }
     validate(unsafeValue = this.value) {
         const path = super.validate(unsafeValue);
-        const extension = getOptionalFileExtension(path);
+        const extension = getFileExtension(path);
         if (!extension)
             throw new ValueFeedback("Must be file name with extension", unsafeValue);
         if (this.types && !isProp(this.types, extension))

package/schema/LinkSchema.js

@@ -1,5 +1,5 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { getOptionalLinkURL } from "../util/link.js";
+import { getLinkURL } from "../util/link.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { TextSchema } from "./TextSchema.js";
 /**
@@ -28,7 +28,7 @@ export class LinkSchema extends TextSchema {
     // Override to clean the URL using builtin helper functions and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {
         const str = super.validate(unsafeValue);
-        const url = getOptionalLinkURL(str, this.base, this.schemes, this.hosts);
+        const url = getLinkURL(str, this.base, this.schemes, this.hosts);
         if (!url)
             throw new ValueFeedback(str ? "Invalid format" : "Required", str);
         return url.href;

package/schema/SlugSchema.js

@@ -1,4 +1,4 @@
-import { getSlug } from "../util/string.js";
+import { requireSlug } from "../util/string.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
@@ -17,7 +17,7 @@ export class SlugSchema extends StringSchema {
         });
     }
     sanitize(str) {
-        return getSlug(str);
+        return requireSlug(str);
     }
 }
 /** Valid slug, e.g. `this-is-a-slug` */

package/schema/TimeSchema.js

@@ -1,6 +1,6 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { roundStep } from "../util/number.js";
-import { Time, getOptionalTime } from "../util/time.js";
+import { Time, getTime } from "../util/time.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
@@ -14,12 +14,12 @@ export class TimeSchema extends Schema {
     step;
     constructor({ min, max, step = 60, title = "Time", value = "now", ...options }) {
         super({ title, value, ...options });
-        this.min = getOptionalTime(min);
-        this.max = getOptionalTime(max);
+        this.min = getTime(min);
+        this.max = getTime(max);
         this.step = step;
     }
     validate(unsafeValue = this.value) {
-        const optionalTime = getOptionalTime(unsafeValue);
+        const optionalTime = getTime(unsafeValue);
         if (!optionalTime)
             throw new ValueFeedback(unsafeValue ? "Invalid time" : "Required", unsafeValue);
         const roundedTime = typeof this.step === "number" ? new Time(roundStep(optionalTime.time, this.step)) : optionalTime;

package/sequence/InspectSequence.js

@@ -1,4 +1,5 @@
-import { ConflictError } from "../error/ConflictError.js";
+import { UnexpectedError } from "../error/UnexpectedError.js";
+import { getGetter } from "../util/class.js";
 import { ThroughSequence } from "./ThroughSequence.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectSequence.NOVALUE");
@@ -20,21 +21,30 @@ export class InspectSequence extends ThroughSequence {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new ConflictError("Iteration not started");
+            throw new UnexpectedError("Iteration not started", {
+                sequence: this,
+                caller: getGetter(this, "first"),
+            });
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new ConflictError("Iteration not started");
+            throw new UnexpectedError("Iteration not started", {
+                sequence: this,
+                caller: getGetter(this, "last"),
+            });
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new ConflictError("Iteration not done");
+            throw new UnexpectedError("Iteration not done", {
+                sequence: this,
+                caller: getGetter(this, "returned"),
+            });
         return this._returned;
     }
     _returned = _NOVALUE;

package/store/ArrayStore.js

@@ -1,4 +1,5 @@
-import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem, omitArrayItems, toggleArrayItems, withArrayItems, } from "../util/array.js";
+import { omitArrayItems, toggleArrayItems, withArrayItems } from "../util/array.js";
+import { getFirstItem, getLastItem, requireFirstItem, requireLastItem } from "../util/iterate.js";
 import { Store } from "./Store.js";
 /** Store an array. */
 export class ArrayStore extends Store {
@@ -7,19 +8,19 @@ export class ArrayStore extends Store {
     }
     /** Get the first item in this store or `null` if this query has no items. */
     get optionalFirst() {
-        return getOptionalFirstItem(this.value);
+        return getFirstItem(this.value);
     }
     /** Get the last item in this store or `null` if this query has no items. */
     get optionalLast() {
-        return getOptionalLastItem(this.value);
+        return getLastItem(this.value);
     }
     /** Get the first item in this store. */
     get first() {
-        return getFirstItem(this.value);
+        return requireFirstItem(this.value);
     }
     /** Get the last item in this store. */
     get last() {
-        return getLastItem(this.value);
+        return requireLastItem(this.value);
     }
     /** Does the document have at least one result. */
     get exists() {

package/store/PathStore.js

@@ -1,9 +1,9 @@
-import { getPath, isPathActive, isPathProud } from "../util/path.js";
+import { isPathActive, isPathProud, requirePath } from "../util/path.js";
 import { Store } from "./Store.js";
 /** Store an absolute path, e.g. `/a/b/c` */
 export class PathStore extends Store {
     constructor(path = ".", time) {
-        super(getPath(path), time);
+        super(requirePath(path), time);
     }
     /** Based on the current store path, is a path active? */
     isActive(path) {
@@ -15,10 +15,10 @@ export class PathStore extends Store {
     }
     /** Get an absolute path from a path relative to the current store path. */
     getPath(path) {
-        return getPath(path, this.value);
+        return requirePath(path, this.value);
     }
     // Override to clean the path.
     set(path) {
-        super.set(getPath(path, this.value));
+        super.set(requirePath(path, this.value));
     }
 }

package/test/util.js

@@ -1,5 +1,4 @@
 import { expect } from "bun:test";
-import { popErrorStack } from "../util/error.js";
 import { getItemIDs } from "../util/item.js";
 /** Expect that an object matches `PromiseLike` */
 export const EXPECT_PROMISELIKE = expect.objectContaining({
@@ -13,7 +12,9 @@ export function expectUnorderedItems(items, keys) {
         expect(Array.from(getItemIDs(items)).sort()).toEqual(Array.from(keys).sort());
     }
     catch (thrown) {
-        throw thrown instanceof Error ? popErrorStack(thrown) : thrown;
+        if (thrown instanceof Error)
+            Error.captureStackTrace(thrown, expectUnorderedItems);
+        throw thrown;
     }
 }
 /** Expect `Item` objects with an `.id` prop in a specified order. */
@@ -23,6 +24,8 @@ export function expectOrderedItems(items, keys) {
         expect(Array.from(getItemIDs(items))).toEqual(Array.from(keys));
     }
     catch (thrown) {
-        throw thrown instanceof Error ? popErrorStack(thrown) : thrown;
+        if (thrown instanceof Error)
+            Error.captureStackTrace(thrown, expectOrderedItems);
+        throw thrown;
     }
 }

package/util/array.d.ts

@@ -21,39 +21,36 @@ export declare function isArrayItem<T>(arr: ImmutableArray<T>, item: unknown): i
 /** 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). */
-export declare function getArray<T>(items: PossibleArray<T>): ImmutableArray<T>;
+export declare function getArray<T>(list: PossibleArray<T>): ImmutableArray<T>;
 /** Add multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
-export declare function withArrayItems<T>(arr: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
+export declare function withArrayItems<T>(list: PossibleArray<T>, ...add: T[]): ImmutableArray<T>;
 /** Pick 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 pickArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...pick: T[]): ImmutableArray<T>;
+export declare function pickArrayItems<T>(items: PossibleArray<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>;
+export declare function omitArrayItems<T>(items: PossibleArray<T>, ...omit: 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. */
-export declare function getOptionalFirstItem<T>(items: PossibleArray<T>): T | undefined;
-/** Get the first item from an array or iterable. */
-export declare function getFirstItem<T>(items: PossibleArray<T>): T;
-/** Get the last item from an array or iterable, or `undefined` if it didn't exist. */
-export declare function getOptionalLastItem<T>(items: PossibleArray<T>): T | undefined;
-/** Get the last item from an array or iterable. */
-export declare function getLastItem<T>(items: PossibleArray<T>): T;
-/** Get the next item in an array or iterable. */
-export declare function getOptionalNextItem<T>(items: PossibleArray<T>, value: T): T | undefined;
-/** Get the previous item in an array or iterable. */
-export declare function getOptionalPrevItem<T>(items: PossibleArray<T>, value: T): T | undefined;
+export declare function toggleArrayItems<T>(items: PossibleArray<T>, ...toggle: T[]): ImmutableArray<T>;
 /** Return a shuffled version of an array or iterable. */
-export declare function shuffleArray<T>(input: PossibleArray<T>): ImmutableArray<T>;
-/** Add an item to an array (by reference) and return the set item. */
+export declare function shuffleArray<T>(items: PossibleArray<T>): ImmutableArray<T>;
+/**
+ * Add an item to an array (by reference) and return the item.
+ * - Skip items that already exist.
+ */
 export declare function addArrayItem<T>(arr: MutableArray<T>, item: T): T;
-/** Add multiple items to an array (by reference). */
+/**
+ * Add multiple items to an array (by reference).
+ * - Skip items that already exist.
+ */
 export declare function addArrayItems<T>(arr: MutableArray<T>, ...items: T[]): void;
-/** Remove multiple items from an array (by reference). */
+/**
+ * Remove multiple items from an array (by reference).
+ * - Skip items that already exist.
+ */
 export declare function deleteArrayItems<T>(arr: MutableArray<T>, ...items: T[]): void;
 /** Return an array of the unique items in an array. */
-export declare function getUniqueArray<T>(input: ImmutableArray<T> | Iterable<T>): ImmutableArray<T>;
+export declare function getUniqueArray<T>(list: PossibleArray<T>): ImmutableArray<T>;
 /** Apply a limit to an array. */
-export declare function limitArray<T>(items: Iterable<T>, limit: number): ImmutableArray<T>;
+export declare function limitArray<T>(list: PossibleArray<T>, limit: number): ImmutableArray<T>;
 /** Count the items in an array. */
 export declare function countArray<T>(arr: ImmutableArray<T>): number;
 /** Does an array have the specified minimum length.  */
@@ -94,22 +91,22 @@ export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 2, max
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): asserts arr is readonly [T, T, T, ...T[]];
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): asserts arr is readonly [T, T, T, T, ...T[]];
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: number, max?: number): asserts arr is ImmutableArray<T>;
-/** Get an array if it has the specified minimum length.  */
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 1, max: 1): [T];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 2, max: 2): [T, T];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 3, max: 3): [T, T, T];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 4, max: 4): [T, T, T, T];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min?: 1, max?: number): [T, ...T[]];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 2, max?: number): [T, T, ...T[]];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 3, max?: number): [T, T, T, ...T[]];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min: 4, max?: number): [T, T, T, T, ...T[]];
-export declare function getArrayLength<T>(arr: MutableArray<T>, min?: number, max?: number): MutableArray<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>;
+/** Require that an array if has the specified minimum length, or throw `RequiredError` if is not. */
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 1, max: 1): [T];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 2, max: 2): [T, T];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 3, max: 3): [T, T, T];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 4, max: 4): [T, T, T, T];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min?: 1, max?: number): [T, ...T[]];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 2, max?: number): [T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 3, max?: number): [T, T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min: 4, max?: number): [T, T, T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: MutableArray<T>, min?: number, max?: number): MutableArray<T>;
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): readonly [T];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): readonly [T, T];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): readonly [T, T, T];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): readonly [T, T, T, T];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): readonly [T, ...T[]];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): readonly [T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): readonly [T, T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): readonly [T, T, T, T, ...T[]];
+export declare function requireArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): ImmutableArray<T>;