shelving 1.157.3 → 1.158.1

package/api/Endpoint.d.ts

@@ -1,5 +1,5 @@
+import { type Schema } from "../schema/Schema.js";
 import type { AbsolutePath } from "../util/path.js";
-import { type Validator } from "../util/validate.js";
 import type { EndpointCallback, EndpointHandler } from "./util.js";
 /** Types for an HTTP request or response that does something. */
 export type EndpointMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -8,8 +8,8 @@ export type EndpointMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
  *
  * @param method The method of the resource, e.g. `GET`
  * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Validator` for the payload of the resource.
- * @param result A `Validator` for the result of the resource.
+ * @param payload A `Schema` for the payload of the resource.
+ * @param result A `Schema` for the result of the resource.
  */
 export declare class Endpoint<P, R> {
     /** Endpoint method. */
@@ -17,10 +17,10 @@ export declare class Endpoint<P, R> {
     /** Endpoint path, e.g. `/patient/{id}` */
     readonly path: AbsolutePath;
     /** Payload validator. */
-    readonly payload: Validator<P>;
+    readonly payload: Schema<P>;
     /** Result validator. */
-    readonly result: Validator<R>;
-    constructor(method: EndpointMethod, path: AbsolutePath, payload: Validator<P>, result: Validator<R>);
+    readonly result: Schema<R>;
+    constructor(method: EndpointMethod, path: AbsolutePath, payload: Schema<P>, result: Schema<R>);
     /**
      * Return an `EndpointHandler` for this endpoint.
      *
@@ -46,34 +46,34 @@ export type EndpointType<X extends Endpoint<unknown, unknown>> = X extends Endpo
  * Represent a GET request to a specified path, with validated payload and return types.
  * "The GET method requests a representation of the specified resource. Requests using GET should only retrieve data and should not contain a request content."
  */
-export declare function GET<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function GET<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function GET<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function GET<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function GET<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function GET<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a POST request to a specified path, with validated payload and return types.
  * "The POST method submits an entity to the specified resource, often causing a change in state or side effects on the server.
  */
-export declare function POST<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function POST<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function POST<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function POST<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function POST<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function POST<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a PUT request to a specified path, with validated payload and return types.
  * "The PUT method replaces all current representations of the target resource with the request content."
  */
-export declare function PUT<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function PUT<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function PUT<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function PUT<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PUT<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PUT<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a PATCH request to a specified path, with validated payload and return types.
  * "The PATCH method applies partial modifications to a resource."
  */
-export declare function PATCH<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function PATCH<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function PATCH<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function PATCH<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PATCH<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PATCH<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a DELETE request to a specified path, with validated payload and return types.
  * "The DELETE method deletes the specified resource."
  */
-export declare function DELETE<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function DELETE<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function DELETE<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function DELETE<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function DELETE<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function DELETE<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;

package/api/Endpoint.js

@@ -1,12 +1,13 @@
+import { UNDEFINED } from "../schema/Schema.js";
 import { getResponse } from "../util/http.js";
-import { UNDEFINED, getValid } from "../util/validate.js";
+import { getValid } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions.
  *
  * @param method The method of the resource, e.g. `GET`
  * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Validator` for the payload of the resource.
- * @param result A `Validator` for the result of the resource.
+ * @param payload A `Schema` for the payload of the resource.
+ * @param result A `Schema` for the result of the resource.
  */
 export class Endpoint {
     /** Endpoint method. */
@@ -53,18 +54,18 @@ export class Endpoint {
         return `${this.method} ${this.path}`;
     }
 }
-export function GET(path, payload, result) {
-    return new Endpoint("GET", path, payload || UNDEFINED, result || UNDEFINED);
+export function GET(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("GET", path, payload, result);
 }
-export function POST(path, payload, result) {
-    return new Endpoint("POST", path, payload || UNDEFINED, result || UNDEFINED);
+export function POST(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("POST", path, payload, result);
 }
-export function PUT(path, payload, result) {
-    return new Endpoint("PUT", path, payload || UNDEFINED, result || UNDEFINED);
+export function PUT(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PUT", path, payload, result);
 }
-export function PATCH(path, payload, result) {
-    return new Endpoint("PATCH", path, payload || UNDEFINED, result || UNDEFINED);
+export function PATCH(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PATCH", path, payload, result);
 }
-export function DELETE(path, payload, result) {
-    return new Endpoint("DELETE", path, payload || UNDEFINED, result || UNDEFINED);
+export function DELETE(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("DELETE", path, payload, result);
 }

package/db/CacheProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Sourceable } from "../util/source.js";

package/db/Change.d.ts

@@ -1,5 +1,5 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier } from "../util/item.js";
 import { type Nullish } from "../util/null.js";
 import type { ItemQuery } from "../util/query.js";

package/db/ChangesProvider.d.ts

@@ -1,5 +1,5 @@
 import type { MutableArray } from "../util/array.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";

package/db/DebugProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";

package/db/ItemStore.d.ts

@@ -1,6 +1,6 @@
 import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Item } from "../util/item.js";
 import type { StopCallback } from "../util/start.js";
 import type { MemoryProvider } from "./MemoryProvider.js";

package/db/MemoryProvider.d.ts

@@ -1,5 +1,5 @@
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
-import type { Data, DataKey, Database } from "../util/data.js";
+import type { Data, Database, DataKey } from "../util/data.js";
 import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";

package/db/Provider.d.ts

@@ -1,4 +1,4 @@
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";

package/db/Provider.js

@@ -1,6 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { countArray } from "../util/array.js";
-import { getFirst } from "../util/array.js";
+import { countArray, getFirst } from "../util/array.js";
 /** Provider with a fully synchronous interface */
 export class Provider {
     requireItem(collection, id) {

package/db/QueryStore.d.ts

@@ -1,6 +1,6 @@
 import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Item } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { StopCallback } from "../util/start.js";

package/db/ThroughProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Sourceable } from "../util/source.js";

package/db/ValidationProvider.d.ts

@@ -1,6 +1,6 @@
 import type { DataSchema, DataSchemas } from "../schema/DataSchema.js";
 import type { Schema } from "../schema/Schema.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier, Items, OptionalItem } from "../util/item.js";
 import type { ItemQuery } from "../util/query.js";
 import type { Sourceable } from "../util/source.js";

package/db/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./ItemStore.js";
-export * from "./QueryStore.js";
-export * from "./Provider.js";
-export * from "./ThroughProvider.js";
 export * from "./CacheProvider.js";
+export * from "./Change.js";
 export * from "./ChangesProvider.js";
 export * from "./DebugProvider.js";
+export * from "./ItemStore.js";
 export * from "./MemoryProvider.js";
+export * from "./Provider.js";
+export * from "./QueryStore.js";
+export * from "./ThroughProvider.js";
 export * from "./ValidationProvider.js";
-export * from "./Change.js";

package/db/index.js

@@ -1,13 +1,13 @@
 // Stores.
-export * from "./ItemStore.js";
-export * from "./QueryStore.js";
-// Providers.
-export * from "./Provider.js";
-export * from "./ThroughProvider.js";
 export * from "./CacheProvider.js";
+// Util.
+export * from "./Change.js";
 export * from "./ChangesProvider.js";
 export * from "./DebugProvider.js";
+export * from "./ItemStore.js";
 export * from "./MemoryProvider.js";
+// Providers.
+export * from "./Provider.js";
+export * from "./QueryStore.js";
+export * from "./ThroughProvider.js";
 export * from "./ValidationProvider.js";
-// Util.
-export * from "./Change.js";

package/error/BaseError.js

@@ -2,7 +2,7 @@
 export class BaseError extends Error {
     constructor(message, options = {}) {
         super(message, options);
-        const { cause, caller = BaseError, ...rest } = options;
+        const { _cause, caller = BaseError, ...rest } = options;
         for (const [key, value] of Object.entries(rest))
             this[key] = value;
         Error.captureStackTrace(this, caller);

package/error/index.d.ts

@@ -1,8 +1,8 @@
 export * from "./BaseError.js";
 export * from "./NetworkError.js";
-export * from "./ResponseError.js";
 export * from "./RequestError.js";
 export * from "./RequiredError.js";
+export * from "./ResponseError.js";
 export * from "./UnexpectedError.js";
 export * from "./UnimplementedError.js";
 export * from "./ValueError.js";

package/error/index.js

@@ -1,8 +1,8 @@
 export * from "./BaseError.js";
 export * from "./NetworkError.js";
-export * from "./ResponseError.js";
 export * from "./RequestError.js";
 export * from "./RequiredError.js";
+export * from "./ResponseError.js";
 export * from "./UnexpectedError.js";
 export * from "./UnimplementedError.js";
 export * from "./ValueError.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,6 +1,6 @@
 import type { Firestore } from "firebase/firestore";
 import { AsyncProvider } from "../../db/Provider.js";
-import type { Data, DataKey, Database } from "../../util/data.js";
+import type { Data, Database, DataKey } from "../../util/data.js";
 import type { Items, OptionalItem } from "../../util/item.js";
 import type { ItemQuery } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,6 +1,6 @@
 import type { Firestore } from "firebase/firestore/lite";
 import { AsyncProvider } from "../../db/Provider.js";
-import type { Data, DataKey, Database } from "../../util/data.js";
+import type { Data, Database, DataKey } from "../../util/data.js";
 import type { Items, OptionalItem } from "../../util/item.js";
 import type { ItemQuery } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,6 +1,6 @@
 import { Firestore } from "@google-cloud/firestore";
 import { AsyncProvider } from "../../db/Provider.js";
-import type { DataKey, Database } from "../../util/data.js";
+import type { Database, DataKey } from "../../util/data.js";
 import type { Items, OptionalItem } from "../../util/item.js";
 import type { ItemQuery } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";

package/markup/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./util/options.js";
-export * from "./util/rule.js";
 export * from "./util/regexp.js";
-export * from "./rule/index.js";
+export * from "./util/rule.js";
 export * from "./render.js";
+export * from "./rule/index.js";

package/markup/index.js

@@ -1,6 +1,6 @@
 export * from "./util/options.js";
-export * from "./util/rule.js";
 export * from "./util/regexp.js";
+export * from "./util/rule.js";
 // export * from "./util/internal.js"; // Not exported.
-export * from "./rule/index.js";
 export * from "./render.js";
+export * from "./rule/index.js";

package/markup/render.js

@@ -27,8 +27,8 @@ context,
 offset = 0) {
     // The best matched rule is the one with the highest priority.
     // If two have equal priority use the earliest match in the string.
-    let bestMatch = undefined;
-    let bestRule = undefined;
+    let bestMatch;
+    let bestRule;
     // Loop through all rules in the list and see if any match.
     for (const rule of options.rules) {
         const { priority, regexp, contexts } = rule;

package/markup/rule/code.js

@@ -10,7 +10,7 @@ const CODE_REGEXP = getRegExp(`(?<fence>\`+)(?<code>${BLOCK_CONTENT_REGEXP})\\k<
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = getMarkupRule(CODE_REGEXP, ({ groups: { code } }, options, key) => ({
+export const CODE_RULE = getMarkupRule(CODE_REGEXP, ({ groups: { code } }, _options, key) => ({
     key,
     $$typeof: REACT_ELEMENT_TYPE,
     type: "code",

package/markup/rule/fenced.js

@@ -1,5 +1,5 @@
 import { REACT_ELEMENT_TYPE } from "../util/internal.js";
-import { BLOCK_CONTENT_REGEXP, BLOCK_START_REGEXP, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP, getBlockRegExp } from "../util/regexp.js";
+import { BLOCK_CONTENT_REGEXP, BLOCK_START_REGEXP, getBlockRegExp, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP } from "../util/regexp.js";
 import { getMarkupRule } from "../util/rule.js";
 const FENCE = "`{3,}|~{3,}";
 const FENCED_REGEXP = getBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`, 
@@ -16,7 +16,7 @@ const FENCED_REGEXP = getBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`,
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code since it's less confusing and more common).
  */
-export const FENCED_RULE = getMarkupRule(FENCED_REGEXP, ({ groups: { title, code } }, options, key) => ({
+export const FENCED_RULE = getMarkupRule(FENCED_REGEXP, ({ groups: { title, code } }, _options, key) => ({
     key,
     $$typeof: REACT_ELEMENT_TYPE,
     type: "pre",

package/markup/rule/heading.js

@@ -1,6 +1,6 @@
 import { renderMarkup } from "../render.js";
 import { REACT_ELEMENT_TYPE } from "../util/internal.js";
-import { LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP, getLineRegExp } from "../util/regexp.js";
+import { getLineRegExp, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP } from "../util/regexp.js";
 import { getMarkupRule } from "../util/rule.js";
 const HEADING_REGEXP = getLineRegExp(`(?<prefix>#{1,6})(?:${LINE_SPACE_REGEXP}+(?<heading>${LINE_CONTENT_REGEXP}))?`);
 /**

package/markup/rule/index.js

@@ -4,8 +4,7 @@ import { FENCED_RULE } from "./fenced.js";
 import { HEADING_RULE } from "./heading.js";
 import { INLINE_RULE } from "./inline.js";
 import { LINEBREAK_RULE } from "./linebreak.js";
-import { LINK_RULE } from "./link.js";
-import { AUTOLINK_RULE } from "./link.js";
+import { AUTOLINK_RULE, LINK_RULE } from "./link.js";
 import { ORDERED_RULE } from "./ordered.js";
 import { PARAGRAPH_RULE } from "./paragraph.js";
 import { SEPARATOR_RULE } from "./separator.js";

package/markup/rule/linebreak.js

@@ -10,7 +10,7 @@ import { getMarkupRule } from "../util/rule.js";
  *   - This is more intuitive (a linebreak becomes a linebreak is isn't silently ignored).
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
-export const LINEBREAK_RULE = getMarkupRule(/[^\n\S]*\n[^\n\S]*/, (match, options, key) => ({
+export const LINEBREAK_RULE = getMarkupRule(/[^\n\S]*\n[^\n\S]*/, (_match, _options, key) => ({
     key,
     $$typeof: REACT_ELEMENT_TYPE,
     type: "br",

package/markup/rule/ordered.js

@@ -1,6 +1,6 @@
 import { renderMarkup } from "../render.js";
 import { REACT_ELEMENT_TYPE } from "../util/internal.js";
-import { BLOCK_CONTENT_REGEXP, BLOCK_SPACE_REGEXP, LINE_SPACE_REGEXP, getBlockRegExp } from "../util/regexp.js";
+import { BLOCK_CONTENT_REGEXP, BLOCK_SPACE_REGEXP, getBlockRegExp, LINE_SPACE_REGEXP } from "../util/regexp.js";
 import { getMarkupRule } from "../util/rule.js";
 const INDENT = /^\t/gm; // Nesting is recognised with tabs only.
 const NUMBER = "\\d{1,9}[.):]"; // Number for a numbered list, e.g. `1.` or `2)` or `3:` followed by one or more spaces.
@@ -24,7 +24,7 @@ export const ORDERED_RULE = getMarkupRule(ORDERED_REGEXP, ({ groups: { list } },
 /** Parse a markdown list into a set of items elements. */
 function* _getOrderedItems(list, options) {
     let key = 0;
-    for (const [unused, number = "", item = ""] of list.matchAll(ITEM)) {
+    for (const [_unused, number = "", item = ""] of list.matchAll(ITEM)) {
         yield {
             $$typeof: REACT_ELEMENT_TYPE,
             type: "li",

package/markup/rule/separator.js

@@ -9,7 +9,7 @@ const SEPARATOR_REGEXP = getLineRegExp("([-*•+_=])(?: *\\1){2,}");
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const SEPARATOR_RULE = getMarkupRule(SEPARATOR_REGEXP, (match, options, key) => ({
+export const SEPARATOR_RULE = getMarkupRule(SEPARATOR_REGEXP, (_match, _options, key) => ({
     key,
     $$typeof: REACT_ELEMENT_TYPE,
     type: "hr",

package/markup/rule/unordered.js

@@ -1,6 +1,6 @@
 import { renderMarkup } from "../render.js";
 import { REACT_ELEMENT_TYPE } from "../util/internal.js";
-import { BLOCK_CONTENT_REGEXP, BLOCK_SPACE_REGEXP, LINE_SPACE_REGEXP, getBlockRegExp } from "../util/regexp.js";
+import { BLOCK_CONTENT_REGEXP, BLOCK_SPACE_REGEXP, getBlockRegExp, LINE_SPACE_REGEXP } from "../util/regexp.js";
 import { getMarkupRule } from "../util/rule.js";
 const INDENT = /^\t/gm; // Nesting is recognised with tabs only.
 const BULLET = "[-*•+]"; // Allowed bullet symbol.
@@ -25,7 +25,7 @@ export const UNORDERED_RULE = getMarkupRule(UNORDERED_REGEXP, ({ groups: { list
 /** Parse a markdown list into a set of items elements. */
 export function* _getItems(list, options) {
     let key = 0;
-    for (const [unused, item = ""] of list.matchAll(ITEM)) {
+    for (const [_unused, item = ""] of list.matchAll(ITEM)) {
         yield {
             $$typeof: REACT_ELEMENT_TYPE,
             type: "li",

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.157.3",
+	"version": "1.158.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -57,14 +57,14 @@
 		"build:test:unit": "bun test ./dist/**/*.test.js --bail"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^1.9.4",
+		"@biomejs/biome": "^2.2.6",
 		"@google-cloud/firestore": "^7.11.6",
-		"@types/bun": "^1.2.23",
-		"@types/react": "^19.1.16",
-		"@types/react-dom": "^19.1.9",
+		"@types/bun": "^1.3.0",
+		"@types/react": "^19.2.2",
+		"@types/react-dom": "^19.2.2",
 		"firebase": "^11.10.0",
-		"react": "^19.1.1",
-		"react-dom": "^19.1.1",
+		"react": "^19.2.0",
+		"react-dom": "^19.2.0",
 		"typescript": "^5.9.3"
 	},
 	"peerDependencies": {

package/react/createDataContext.d.ts

@@ -2,7 +2,7 @@ import type { ReactElement, ReactNode } from "react";
 import { ItemStore } from "../db/ItemStore.js";
 import type { AbstractProvider } from "../db/Provider.js";
 import { QueryStore } from "../db/QueryStore.js";
-import type { DataKey, Database } from "../util/data.js";
+import type { Database, DataKey } from "../util/data.js";
 import type { Identifier } from "../util/item.js";
 import type { Nullish } from "../util/null.js";
 import type { ItemQuery } from "../util/query.js";

package/schema/ArraySchema.d.ts

@@ -1,11 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
 export interface ArraySchemaOptions<T> extends SchemaOptions {
     readonly value?: ImmutableArray;
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly min?: number;
     readonly max?: number;
     readonly unique?: boolean;
@@ -39,7 +38,7 @@ export interface ArraySchemaOptions<T> extends SchemaOptions {
  */
 export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly value: ImmutableArray;
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly unique: boolean;
     readonly min: number;
     readonly max: number;
@@ -47,4 +46,4 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }
 /** Valid array with specifed items. */
-export declare const ARRAY: <T>(items: Validator<T>) => ArraySchema<T>;
+export declare const ARRAY: <T>(items: Schema<T>) => ArraySchema<T>;

package/schema/DataSchema.d.ts

@@ -1,19 +1,18 @@
 import type { Data, Database } from "../util/data.js";
 import type { Identifier, Item } from "../util/item.js";
-import type { Validator, Validators } from "../util/validate.js";
 import type { NullableSchema } from "./NullableSchema.js";
-import type { SchemaOptions } from "./Schema.js";
+import type { SchemaOptions, Schemas } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `PropsSchema` (a schema that has props). */
 export interface DataSchemaOptions<T extends Data> extends SchemaOptions {
-    readonly id?: Validator<string>;
-    readonly props: Validators<T>;
+    readonly id?: Schema<string>;
+    readonly props: Schemas<T>;
     readonly value?: Partial<T> | undefined;
 }
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<unknown> {
     readonly value: Partial<T>;
-    readonly props: Validators<T>;
+    readonly props: Schemas<T>;
     constructor({ props, title, value, ...options }: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
 }
@@ -22,10 +21,10 @@ export type DataSchemas<T extends Database> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
 /** Create a `DataSchema` for a set of properties. */
-export declare const DATA: <T extends Data>(props: Validators<T>) => DataSchema<T>;
+export declare const DATA: <T extends Data>(props: Schemas<T>) => DataSchema<T>;
 /** Valid data object with specifed properties, or `null` */
-export declare const NULLABLE_DATA: <T extends Data>(props: Validators<T>) => NullableSchema<T>;
+export declare const NULLABLE_DATA: <T extends Data>(props: Schemas<T>) => NullableSchema<T>;
 /** Create a `DataSchema` that validates partially, i.e. properties can be their value, or `undefined` */
-export declare function PARTIAL<T extends Data>(source: Validators<T> | DataSchema<T>): DataSchema<Partial<T>>;
+export declare function PARTIAL<T extends Data>(source: Schemas<T> | DataSchema<T>): DataSchema<Partial<T>>;
 /** Create a `DataSchema` that validates a data item, i.e. it has a string or number `.id` identifier property. */
-export declare function ITEM<I extends Identifier, T extends Data>(id: Validator<I>, validators: Validators<T> | DataSchema<T>): DataSchema<Item<I, T>>;
+export declare function ITEM<I extends Identifier, T extends Data>(id: Schema<I>, schemas: Schemas<T> | DataSchema<T>): DataSchema<Item<I, T>>;

package/schema/DataSchema.js

@@ -32,8 +32,8 @@ function _optionalProp([, v]) {
     return OPTIONAL(v);
 }
 /** Create a `DataSchema` that validates a data item, i.e. it has a string or number `.id` identifier property. */
-export function ITEM(id, validators) {
-    const props = validators instanceof DataSchema ? validators.props : validators;
+export function ITEM(id, schemas) {
+    const props = schemas instanceof DataSchema ? schemas.props : schemas;
     return new DataSchema({
         props: { id, ...props },
     });

package/schema/DictionarySchema.d.ts

@@ -1,10 +1,9 @@
 import type { ImmutableDictionary } from "../util/dictionary.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
 export interface DictionarySchemaOptions<T> extends SchemaOptions {
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly value?: ImmutableDictionary | undefined;
     readonly min?: number | undefined;
     readonly max?: number | undefined;
@@ -12,11 +11,11 @@ export interface DictionarySchemaOptions<T> extends SchemaOptions {
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>> {
     readonly value: ImmutableDictionary;
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly min: number;
     readonly max: number;
     constructor({ items, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }
 /** Valid dictionary object with specifed items. */
-export declare const DICTIONARY: <T>(items: Validator<T>) => DictionarySchema<T>;
+export declare const DICTIONARY: <T>(items: Schema<T>) => DictionarySchema<T>;

package/schema/NullableSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Validator } from "../index.js";
+import type { Schema } from "./Schema.js";
 import { ThroughSchema, type ThroughSchemaOptions } from "./ThroughSchema.js";
 /** Allowed options for `NullableSchema` */
 export interface NullableSchemaOptions<T> extends ThroughSchemaOptions<T | null> {
@@ -12,4 +12,4 @@ export declare class NullableSchema<T> extends ThroughSchema<T | null> {
     validate(unsafeValue?: unknown): T | null;
 }
 /** Create a new nullable schema from a source schema. */
-export declare const NULLABLE: <T>(source: Validator<T>) => NullableSchema<T>;
+export declare const NULLABLE: <T>(source: Schema<T>) => NullableSchema<T>;

package/schema/OptionalSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Validator } from "../util/validate.js";
+import type { Schema } from "./Schema.js";
 import { ThroughSchema, type ThroughSchemaOptions } from "./ThroughSchema.js";
 export interface OptionalSchemaOptions<T> extends ThroughSchemaOptions<T | undefined> {
     /** Default value for an `OptionalSchema` can always `undefined` */
@@ -16,4 +16,4 @@ export declare class OptionalSchema<T> extends ThroughSchema<T | undefined> {
     validate(unsafeValue: unknown): T | undefined;
 }
 /** Make a property of a set of data optional, i.e. it can be the value or `undefined` */
-export declare const OPTIONAL: <T>(source: Validator<T>) => OptionalSchema<T>;
+export declare const OPTIONAL: <T>(source: Schema<T>) => OptionalSchema<T>;

package/schema/Schema.d.ts

@@ -1,3 +1,4 @@
+import type { Data } from "../util/data.js";
 import type { Validator } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
@@ -28,3 +29,10 @@ export declare abstract class Schema<T = unknown> implements Validator<T> {
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }
+/** A set of named schemas in `{ name: schema }` format. */
+export type Schemas<T extends Data = Data> = {
+    readonly [K in keyof T]: Schema<T[K]>;
+};
+export declare const UNKNOWN: Schema<unknown>;
+export declare const UNDEFINED: Schema<undefined>;
+export declare const NULL: Schema<null>;

package/schema/Schema.js

@@ -1,3 +1,6 @@
+import { PASSTHROUGH } from "../util/function.js";
+import { getNull } from "../util/null.js";
+import { getUndefined } from "../util/undefined.js";
 /**
  * Schema is an object instance with a `validate()` method.
  * - Type `T` represents the type of value `validate()` returns.
@@ -19,3 +22,9 @@ export class Schema {
         this.value = value;
     }
 }
+// Unknown validator always passes through its input value as `unknown`
+export const UNKNOWN = { title: "", description: "", placeholder: "", value: undefined, validate: PASSTHROUGH };
+// Undefined validator always returns `undefined`
+export const UNDEFINED = { ...UNKNOWN, validate: getUndefined };
+// Null validator always returns `null`
+export const NULL = { ...UNKNOWN, validate: getNull };

package/schema/ThroughSchema.d.ts

@@ -1,14 +1,13 @@
 import type { Sourceable } from "../util/source.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ThroughSchema` */
 export interface ThroughSchemaOptions<T> extends SchemaOptions {
-    source: Validator<T>;
+    source: Schema<T>;
 }
 /** Schema that passes through to a source schema. */
-export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Validator<T>> {
-    readonly source: Validator<T>;
+export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Schema<T>> {
+    readonly source: Schema<T>;
     constructor({ source, ...options }: ThroughSchemaOptions<T>);
     validate(unsafeValue: unknown): T;
 }

package/schema/index.d.ts

@@ -1,8 +1,3 @@
-export * from "./Schema.js";
-export * from "./ThroughSchema.js";
-export * from "./NullableSchema.js";
-export * from "./OptionalSchema.js";
-export * from "./RequiredSchema.js";
 export * from "./ArraySchema.js";
 export * from "./BooleanSchema.js";
 export * from "./ChoiceSchema.js";
@@ -16,9 +11,14 @@ export * from "./EntitySchema.js";
 export * from "./FileSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
+export * from "./NullableSchema.js";
 export * from "./NumberSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
+export * from "./RequiredSchema.js";
+export * from "./Schema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
+export * from "./ThroughSchema.js";
 export * from "./TimeSchema.js";
 export * from "./UUIDSchema.js";

package/schema/index.js

@@ -1,9 +1,3 @@
-export * from "./Schema.js";
-// Utility schemas.
-export * from "./ThroughSchema.js";
-export * from "./NullableSchema.js";
-export * from "./OptionalSchema.js";
-export * from "./RequiredSchema.js";
 // Field schemas.
 export * from "./ArraySchema.js";
 export * from "./BooleanSchema.js";
@@ -18,9 +12,15 @@ export * from "./EntitySchema.js";
 export * from "./FileSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
+export * from "./NullableSchema.js";
 export * from "./NumberSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
+export * from "./RequiredSchema.js";
+export * from "./Schema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
+// Utility schemas.
+export * from "./ThroughSchema.js";
 export * from "./TimeSchema.js";
 export * from "./UUIDSchema.js";

package/sequence/DeferredSequence.js

@@ -40,7 +40,9 @@ export class DeferredSequence extends AbstractSequence {
     }
     /** Fulfill the current deferred by resolving or rejecting it. */
     _fulfill() {
-        const { _deferred, _nextReason, _nextValue } = this;
+        const _deferred = this._deferred;
+        const _nextReason = this._nextReason;
+        const _nextValue = this._nextValue;
         this._nextReason = _NOVALUE;
         this._nextValue = _NOVALUE;
         if (_deferred) {

package/sequence/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./AbstractSequence.js";
 export * from "./DeferredSequence.js";
 export * from "./InspectSequence.js";
+export * from "./IteratorSequence.js";
 export * from "./LazyDeferredSequence.js";
 export * from "./ThroughSequence.js";
-export * from "./IteratorSequence.js";

package/sequence/index.js

@@ -1,6 +1,6 @@
 export * from "./AbstractSequence.js";
 export * from "./DeferredSequence.js";
 export * from "./InspectSequence.js";
+export * from "./IteratorSequence.js";
 export * from "./LazyDeferredSequence.js";
 export * from "./ThroughSequence.js";
-export * from "./IteratorSequence.js";

package/store/ArrayStore.js

@@ -1,5 +1,4 @@
-import { omitArrayItems, toggleArrayItems, withArrayItems } from "../util/array.js";
-import { getFirst, getLast, requireFirst, requireLast } from "../util/array.js";
+import { getFirst, getLast, omitArrayItems, requireFirst, requireLast, toggleArrayItems, withArrayItems } from "../util/array.js";
 import { Store } from "./Store.js";
 /** Store an array. */
 export class ArrayStore extends Store {

package/store/index.d.ts

@@ -1,6 +1,6 @@
-export * from "./Store.js";
 export * from "./ArrayStore.js";
 export * from "./BooleanStore.js";
 export * from "./DataStore.js";
-export * from "./PathStore.js";
 export * from "./DictionaryStore.js";
+export * from "./PathStore.js";
+export * from "./Store.js";

package/store/index.js

@@ -1,6 +1,6 @@
-export * from "./Store.js";
 export * from "./ArrayStore.js";
 export * from "./BooleanStore.js";
 export * from "./DataStore.js";
-export * from "./PathStore.js";
 export * from "./DictionaryStore.js";
+export * from "./PathStore.js";
+export * from "./Store.js";

package/util/array.d.ts

@@ -27,7 +27,7 @@ export declare function isArray<T>(arr: ImmutableArray<T>, min: 3, max: 3): arr
 export declare function isArray<T>(arr: ImmutableArray<T>, min?: 1, max?: number): arr is readonly [T, ...T[]];
 export declare function isArray<T>(arr: ImmutableArray<T>, min: 2, max?: number): arr is readonly [T, T, ...T[]];
 export declare function isArray<T>(arr: ImmutableArray<T>, min: 3, max?: number): arr is readonly [T, T, T, ...T[]];
-export declare function isArray<T>(value: unknown, min?: number, max?: number): value is ImmutableArray;
+export declare function isArray<T>(value: unknown, min?: number, max?: number): value is ImmutableArray<T>;
 /** Assert that an unknown value is an array (optionally with specified min/max length). */
 export declare function assertArray<T>(arr: MutableArray<T>, min: 1, max: 1, caller?: AnyCaller): asserts arr is [T];
 export declare function assertArray<T>(arr: MutableArray<T>, min: 2, max: 2, caller?: AnyCaller): asserts arr is [T, T];

package/util/function.d.ts

@@ -14,4 +14,4 @@ export type Arguments = readonly unknown[];
 /** Function that just passes through the first argument. */
 export declare function PASSTHROUGH<T>(value: T): T;
 /** Function that does nothing with its arguments and always returns void. */
-export declare function BLACKHOLE(...unused: Arguments): void | undefined;
+export declare function BLACKHOLE(..._unused: Arguments): void | undefined;

package/util/function.js

@@ -14,6 +14,6 @@ export function PASSTHROUGH(value) {
 }
 /** Function that does nothing with its arguments and always returns void. */
 // biome-ignore lint/suspicious/noConfusingVoidType: Allow `BLACKHOLE` to be used in places that allow `void`
-export function BLACKHOLE(...unused) {
+export function BLACKHOLE(..._unused) {
     return undefined;
 }

package/util/iterate.js

@@ -13,14 +13,14 @@ export function* flattenItems(items) {
  * - Checks `items.size` or `items.length` first, or consumes the iterable and counts its iterations.
  */
 export function hasItems(items) {
-    for (const unused of items)
+    for (const _unused of items)
         return true;
     return false;
 }
 /** Count the number of items in an iterable. */
 export function countItems(items) {
     let count = 0;
-    for (const unused of items)
+    for (const _unused of items)
         count++;
     return count;
 }

package/util/jwt.js

@@ -84,9 +84,9 @@ export async function verifyToken(token, secret, caller = verifyToken) {
     const { header, payload, signature, headerData, payloadData } = splitToken(token, caller);
     // Validate header.
     if (headerData.typ !== HEADER.typ)
-        throw new UnauthorizedError(`JWT header type must be \"${HEADER.typ}\"`, { received: headerData.typ, caller });
+        throw new UnauthorizedError(`JWT header type must be "${HEADER.typ}"`, { received: headerData.typ, caller });
     if (headerData.alg !== HEADER.alg)
-        throw new UnauthorizedError(`JWT header algorithm must be \"${HEADER.alg}\"`, { received: headerData.alg, caller });
+        throw new UnauthorizedError(`JWT header algorithm must be "${HEADER.alg}"`, { received: headerData.alg, caller });
     // Validate signature.
     const key = await _getKey(verifyToken, secret, "verify");
     const isValid = await crypto.subtle.verify("HMAC", key, decodeBase64URLBytes(signature), requireBytes(`${header}.${payload}`));

package/util/merge.d.ts

@@ -5,7 +5,7 @@ type MergeRecursor = (left: unknown, right: unknown) => unknown;
  * Exact merge two unknown values.
  * - Always returns `right`.
  */
-export declare function exactMerge(left: unknown, right: unknown): unknown;
+export declare function exactMerge(_left: unknown, right: unknown): unknown;
 /**
  * Shallow merge two unknown values.
  *

package/util/merge.js

@@ -14,7 +14,7 @@ function _merge(left, right, recursor) {
  * Exact merge two unknown values.
  * - Always returns `right`.
  */
-export function exactMerge(left, right) {
+export function exactMerge(_left, right) {
     return right;
 }
 export function shallowMerge(left, right) {

package/util/number.js

@@ -158,7 +158,7 @@ export function sumNumbers(nums) {
 }
 /** Find the number that's closest to a target in an iterable set of numbers. */
 export function getClosestNumber(nums, target) {
-    let closest = undefined;
+    let closest;
     for (const item of nums)
         if (closest === undefined || Math.abs(item - target) < Math.abs(closest - target))
             closest = item;

package/util/query.js

@@ -1,5 +1,4 @@
-import { isArray, limitArray } from "./array.js";
-import { requireLast } from "./array.js";
+import { isArray, limitArray, requireLast } from "./array.js";
 import { getDataProp } from "./data.js";
 import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "./equal.js";
 import { limitItems } from "./iterate.js";

package/util/random.d.ts

@@ -13,4 +13,4 @@ export declare function getRandomKey(length?: number): string;
 /** Get a random character from a string. */
 export declare function getRandomCharacter(str: string): string;
 /** Get a random item from an array or random character from a string string. */
-export declare function getRandomItem<I, T>(arr: ImmutableArray<T>): T;
+export declare function getRandomItem<T>(arr: ImmutableArray<T>): T;

package/util/sequence.d.ts

@@ -1,5 +1,4 @@
-import type { AsyncValueCallback, ValueCallback } from "./callback.js";
-import type { ErrorCallback } from "./callback.js";
+import type { AsyncValueCallback, ErrorCallback, ValueCallback } from "./callback.js";
 import { STOP } from "./constants.js";
 import type { StopCallback } from "./start.js";
 /**

package/util/set.d.ts

@@ -16,11 +16,11 @@ export declare function getSet<T>(value: PossibleSet<T>): ImmutableSet;
 /** Apply a limit to a set. */
 export declare function limitSet<T>(set: ImmutableSet<T>, limit: number): ImmutableSet<T>;
 /** Is an unknown value an item in a set? */
-export declare function isSetItem<I, T>(set: ImmutableSet<T>, item: unknown): item is T;
+export declare function isSetItem<T>(set: ImmutableSet<T>, item: unknown): item is T;
 /** Assert that an unknown value is an item in a set. */
-export declare function assertSetItem<I, T>(set: ImmutableSet<T>, item: unknown, caller?: AnyCaller): asserts item is T;
+export declare function assertSetItem<T>(set: ImmutableSet<T>, item: unknown, caller?: AnyCaller): asserts item is T;
 /** Add an item to a set (by reference) and return the set item. */
-export declare function addSetItem<I, T>(set: MutableSet<T>, item: T): T;
+export declare function addSetItem<T>(set: MutableSet<T>, item: T): T;
 /** Add multiple items to a set (by reference). */
 export declare function addSetItems<T>(set: MutableSet<T>, ...items: T[]): void;
 /** Remove multiple items from a set (by reference). */

package/util/url.js

@@ -15,7 +15,7 @@ export function getURL(possible, base = _BASE) {
         try {
             return isURL(possible) ? possible : new URL(possible, base);
         }
-        catch (e) {
+        catch (_e) {
             //
         }
     }

package/util/validate.d.ts

@@ -64,6 +64,3 @@ export declare function validateDictionary<T>(unsafeDictionary: ImmutableDiction
  */
 export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial: true): DeepPartial<T>;
 export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial?: false): T;
-export declare const UNDEFINED: Validator<undefined>;
-export declare const NULL: Validator<null>;
-export declare const UNKNOWN: Validator<unknown>;

package/util/validate.js

@@ -4,10 +4,7 @@ import { isArray } from "./array.js";
 import { getDataKeys, getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
 import { getNamedMessage } from "./error.js";
-import { PASSTHROUGH } from "./function.js";
 import { isIterable } from "./iterate.js";
-import { getNull } from "./null.js";
-import { getUndefined } from "./undefined.js";
 /** Get value that validates against a given `Validator`, or throw `ValueError` */
 export function getValid(value, validator, ErrorConstructor = ValueError, caller = getValid) {
     try {
@@ -135,9 +132,3 @@ export function validateData(unsafeData, validators, partial = isDeeplyPartial)
         isDeeplyPartial = false;
     }
 }
-// Undefined validator always returns `undefined`
-export const UNDEFINED = { validate: getUndefined };
-// Null validator always returns `null`
-export const NULL = { validate: getNull };
-// Unknown validator always passes through its input value as `unknown`
-export const UNKNOWN = { validate: PASSTHROUGH };