shelving 1.86.0 → 1.86.2

package/schema/AllowSchema.d.ts

@@ -1,21 +1,21 @@
 import type { Entry } from "../util/entry.js";
-import { ImmutableRequiredMap, PossibleMap, PossibleStringMap } from "../util/map.js";
+import { ImmutableMap, PossibleMap, PossibleStringMap } from "../util/map.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `AllowSchama` */
-export declare type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
+export type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
     allow: PossibleMap<K, T>;
 };
 /** Define a valid value from an allowed set of values. */
 export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
     readonly value: K;
-    readonly allow: ImmutableRequiredMap<K, T>;
+    readonly allow: ImmutableMap<K, T>;
     constructor({ allow, ...options }: AllowSchemaOptions<K, T>);
     validate(value?: unknown): K;
     /** Iterate over the the allowed options in `[key, value]` format. */
     [Symbol.iterator](): Iterator<Entry<K, T>>;
 }
 /** Allowed options for `AllowStringSchama` */
-export declare type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
+export type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
     allow: PossibleStringMap<K, T>;
 };
 /** Define a valid string value from an allowed set of string values. */

package/schema/AllowSchema.js

@@ -1,5 +1,5 @@
 import { getString } from "../util/string.js";
-import { getRequiredMap, isMapKey } from "../util/map.js";
+import { getMap, isMapKey } from "../util/map.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getFirstItem } from "../util/array.js";
 import { Schema } from "./Schema.js";
@@ -7,7 +7,7 @@ import { Schema } from "./Schema.js";
 export class AllowSchema extends Schema {
     constructor({ allow, ...options }) {
         super(options);
-        this.allow = getRequiredMap(allow);
+        this.allow = getMap(allow);
         this.value = getFirstItem(this.allow.keys());
     }
     validate(value = this.value) {
@@ -23,7 +23,7 @@ export class AllowSchema extends Schema {
 /** Define a valid string value from an allowed set of string values. */
 export class AllowStringSchema extends AllowSchema {
     constructor({ allow, ...options }) {
-        super({ allow: getRequiredMap(allow), ...options });
+        super({ allow: getMap(allow), ...options });
     }
     validator(value = this.value) {
         return super.validate(getString(value));

package/schema/ArraySchema.d.ts

@@ -2,7 +2,7 @@ import { ImmutableArray } from "../util/array.js";
 import { Validator } from "../util/validate.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
-export declare type ArraySchemaOptions<T> = SchemaOptions & {
+export type ArraySchemaOptions<T> = SchemaOptions & {
     readonly value?: ImmutableArray;
     readonly items: Validator<T>;
     readonly min?: number;

package/schema/BooleanSchema.d.ts

@@ -1,6 +1,6 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `BooleanSchema` */
-export declare type BooleanSchemaOptions = SchemaOptions & {
+export type BooleanSchemaOptions = SchemaOptions & {
     readonly value?: boolean;
 };
 /** Define a valid boolean. */

package/schema/DataSchema.d.ts

@@ -3,7 +3,7 @@ import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DataSchema` */
-export declare type DataSchemaOptions<T extends Data> = SchemaOptions & {
+export type DataSchemaOptions<T extends Data> = SchemaOptions & {
     readonly props: Validators<T>;
     readonly value?: Partial<T>;
 };
@@ -15,7 +15,7 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */
-export declare type DataSchemas<T extends Datas> = {
+export type DataSchemas<T extends Datas> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
 /** Valid data object with specifed properties. */

package/schema/DateSchema.d.ts

@@ -1,7 +1,7 @@
 import { PossibleDate } from "../util/date.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DateSchema` */
-export declare type DateSchemaOptions = SchemaOptions & {
+export type DateSchemaOptions = SchemaOptions & {
     readonly value?: PossibleDate;
     readonly min?: PossibleDate | null;
     readonly max?: PossibleDate | null;

package/schema/DictionarySchema.d.ts

@@ -2,7 +2,7 @@ import { ImmutableDictionary } from "../util/dictionary.js";
 import { Validator } from "../util/validate.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
-export declare type DictionarySchemaOptions<T> = SchemaOptions & {
+export type DictionarySchemaOptions<T> = SchemaOptions & {
     readonly items: Validator<T>;
     readonly value?: ImmutableDictionary;
     readonly min?: number | null;

package/schema/LinkSchema.d.ts

@@ -1,6 +1,6 @@
 import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
-export declare type LinkSchemaOptions = StringSchemaOptions & {
+export type LinkSchemaOptions = StringSchemaOptions & {
     readonly schemes?: string[];
     readonly hosts?: string[] | null;
 };

package/schema/NumberSchema.d.ts

@@ -1,6 +1,6 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `NumberSchema` */
-export declare type NumberSchemaOptions = SchemaOptions & {
+export type NumberSchemaOptions = SchemaOptions & {
     readonly value?: number | null;
     readonly min?: number | null;
     readonly max?: number | null;

package/schema/NumberSchema.js

@@ -1,4 +1,4 @@
-import { getOptionalNumber, roundStep } from "../util/number.js";
+import { formatNumber, getOptionalNumber, roundStep } from "../util/number.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -17,9 +17,9 @@ export class NumberSchema extends Schema {
             throw new InvalidFeedback("Must be number", { value: unsafeValue });
         const safeNumber = typeof this.step === "number" ? roundStep(unsafeNumber, this.step) : unsafeNumber;
         if (typeof this.max === "number" && safeNumber > this.max)
-            throw new InvalidFeedback(`Maximum ${this.max}`, { value: safeNumber });
+            throw new InvalidFeedback(`Maximum ${formatNumber(this.max)}`, { value: safeNumber });
         if (typeof this.min === "number" && safeNumber < this.min)
-            throw new InvalidFeedback(`Minimum ${this.min}`, { value: safeNumber });
+            throw new InvalidFeedback(`Minimum ${formatNumber(this.min)}`, { value: safeNumber });
         return safeNumber;
     }
 }
@@ -28,6 +28,6 @@ export const NUMBER = new NumberSchema({});
 /** Valid number, e.g. `2048.12345` or `0` zero, or `null` */
 export const OPTIONAL_NUMBER = OPTIONAL(NUMBER);
 /** Valid integer number, e.g. `2048` or `0` zero. */
-export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MIN_SAFE_INTEGER });
+export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER });
 /** Valid integer number, e.g. `2048` or `0` zero, or `null` */
 export const OPTIONAL_INTEGER = OPTIONAL(INTEGER);

package/schema/Schema.d.ts

@@ -1,6 +1,6 @@
 import type { Validatable } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
-export declare type SchemaOptions = {
+export type SchemaOptions = {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
     readonly title?: string | null;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */

package/schema/StringSchema.d.ts

@@ -1,10 +1,10 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
-export declare type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
+export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Function that sanitizes a string. */
-export declare type Sanitizer = (str: string) => string;
+export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
-export declare type StringSchemaOptions = SchemaOptions & {
+export type StringSchemaOptions = SchemaOptions & {
     readonly value?: string;
     readonly type?: HtmlInputType;
     readonly min?: number;

package/schema/ThroughSchema.d.ts

@@ -1,7 +1,7 @@
 import type { Sourceable } from "../util/source.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `ThroughSchama` */
-export declare type ThroughSchemaOptions<T> = SchemaOptions & {
+export type ThroughSchemaOptions<T> = SchemaOptions & {
     source: Schema<T>;
 };
 /** Schema that passes through to a source schema. */

package/schema/TimeSchema.d.ts

@@ -1,7 +1,7 @@
 import { PossibleTime, Time } from "../util/time.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
-export declare type TimeSchemaOptions = SchemaOptions & {
+export type TimeSchemaOptions = SchemaOptions & {
     readonly value?: PossibleTime;
     readonly min?: PossibleTime | null;
     readonly max?: PossibleTime | null;

package/state/State.d.ts

@@ -1,7 +1,7 @@
 import { Dispatch, Handler, Stop } from "../util/function.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /** Any `State` instance. */
-export declare type AnyState = State<any>;
+export type AnyState = State<any>;
 /**
  * Stream that retains its most recent value
  * - Current value can be read at `state.value` and `state.data`

package/state/State.js

@@ -11,12 +11,6 @@ import { DeferredSequence } from "../sequence/DeferredSequence.js";
  * - To set the state to an explicit value, use that value or another `State` instance with a value.
  * */
 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.next = next;
-    }
     /** Most recently dispatched value (or throw `Promise` that resolves to the next value). */
     get value() {
         if (this._value === State.NOVALUE)
@@ -32,6 +26,12 @@ export class State {
         const time = this.time;
         return time !== null ? Date.now() - time : Infinity;
     }
+    /** 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.next = next;
+    }
     /** Is there a current value, or is it still loading. */
     get loading() {
         return this._value === State.NOVALUE;

package/test/basics.d.ts

@@ -6,8 +6,8 @@ export declare const BASIC_SCHEMA: import("../schema/DataSchema.js").DataSchema<
     group: "a" | "b" | "c";
     tags: import("../index.js").ImmutableArray<string>;
 }>;
-export declare type BasicData = ValidatorType<typeof BASIC_SCHEMA>;
-export declare type BasicItemData = ItemData<BasicData>;
+export type BasicData = ValidatorType<typeof BASIC_SCHEMA>;
+export type BasicItemData = ItemData<BasicData>;
 export declare const basic1: BasicItemData;
 export declare const basic2: BasicItemData;
 export declare const basic3: BasicItemData;

package/test/index.d.ts

@@ -17,4 +17,4 @@ export declare const TEST_COLLECTIONS: {
         birthday: string | null;
     }>;
 };
-export declare type TestCollections = ValidatorsType<typeof TEST_COLLECTIONS>;
+export type TestCollections = ValidatorsType<typeof TEST_COLLECTIONS>;

package/test/people.d.ts

@@ -7,8 +7,8 @@ export declare const PERSON_SCHEMA: import("../schema/DataSchema.js").DataSchema
     };
     birthday: string | null;
 }>;
-export declare type PersonData = ValidatorType<typeof PERSON_SCHEMA>;
-export declare type PersonItemData = ItemData<PersonData>;
+export type PersonData = ValidatorType<typeof PERSON_SCHEMA>;
+export type PersonItemData = ItemData<PersonData>;
 export declare const person1: PersonItemData;
 export declare const person2: PersonItemData;
 export declare const person3: PersonItemData;

package/update/ArrayUpdate.d.ts

@@ -1,3 +1,4 @@
+import { ArraySchema } from "../schema/ArraySchema.js";
 import { ImmutableArray } from "../util/array.js";
 import { Validator } from "../util/validate.js";
 import { Update } from "./Update.js";
@@ -15,5 +16,5 @@ export declare class ArrayUpdate<T> extends Update<ImmutableArray<T>> {
     /** Return an array update with an additional item marked for deletion. */
     delete(...deletes: T[]): this;
     transform(arr?: ImmutableArray<T>): ImmutableArray<T>;
-    validate(validator: Validator<ImmutableArray<T>>): this;
+    validate(validator: ArraySchema<T> | Validator<ImmutableArray<T>>): this;
 }

package/update/ArrayUpdate.js

@@ -1,14 +1,10 @@
 import { ArraySchema } from "../schema/ArraySchema.js";
 import { withArrayItems, omitArrayItems } from "../util/array.js";
+import { getPrototype } from "../util/object.js";
 import { validateArray } from "../util/validate.js";
 import { Update } from "./Update.js";
 /** Update that can be applied to an array to add/remove items. */
 export class ArrayUpdate extends Update {
-    constructor(adds = [], deletes = []) {
-        super();
-        this.adds = adds;
-        this.deletes = deletes;
-    }
     /** Return an array update with an item marked for addition. */
     static add(...adds) {
         return new ArrayUpdate(adds);
@@ -17,10 +13,15 @@ export class ArrayUpdate extends Update {
     static delete(...deletes) {
         return new ArrayUpdate([], deletes);
     }
+    constructor(adds = [], deletes = []) {
+        super();
+        this.adds = adds;
+        this.deletes = deletes;
+    }
     /** Return an array update with an additional item marked for addition. */
     add(...adds) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             adds: [...this.adds, ...adds],
         };
@@ -28,7 +29,7 @@ export class ArrayUpdate extends Update {
     /** Return an array update with an additional item marked for deletion. */
     delete(...deletes) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             deletes: [...this.deletes, ...deletes],
         };
@@ -42,7 +43,7 @@ export class ArrayUpdate extends Update {
         if (!(validator instanceof ArraySchema))
             return super.validate(validator);
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             adds: validateArray(this.adds, validator.items),
             deletes: validateArray(this.deletes, validator.items),

package/update/DataUpdate.d.ts

@@ -9,7 +9,7 @@ import { Update } from "./Update.js";
  * - If a prop contains a new value, the prop is set to that new value.
  * - If a prop contains an `Update` instance, the existing value is updated.
  */
-export declare type Updates<T extends Data = Data> = {
+export type Updates<T extends Data = Data> = {
     readonly [K in keyof T]?: T[K] | Update<T[K]> | undefined;
 };
 /**

package/update/DataUpdate.js

@@ -3,6 +3,7 @@ import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { DataSchema } from "../schema/DataSchema.js";
 import { getDataProps } from "../util/data.js";
 import { isNullish } from "../util/null.js";
+import { getPrototype } from "../util/object.js";
 import { transformObject } from "../util/transform.js";
 import { validate } from "../util/validate.js";
 import { Update } from "./Update.js";
@@ -36,20 +37,20 @@ export const updateData = transformObject;
  * Update that can be applied to a data object to update its props.
  */
 export class DataUpdate extends Update {
-    constructor(props) {
-        super();
-        this.updates = props;
-    }
     /** Return a data update with a specific prop marked for update. */
     static update(key, value) {
         return new DataUpdate(!isNullish(key) ? { [key]: value } : {});
     }
+    constructor(props) {
+        super();
+        this.updates = props;
+    }
     /** Return a data update with a specific prop marked for update. */
     update(key, value) {
         if (isNullish(key))
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             updates: { ...this.updates, [key]: value },
         };
@@ -63,7 +64,7 @@ export class DataUpdate extends Update {
         if (!(validator instanceof DataSchema))
             return super.validate(validator);
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             updates: validateUpdates(this.updates, validator.props),
         };

package/update/DictionaryUpdate.d.ts

@@ -5,7 +5,7 @@ import { Validator } from "../util/validate.js";
 import { Update } from "./Update.js";
 import { Delete } from "./Delete.js";
 /** Set of named transforms for the entries of a dictionary object. */
-export declare type DictionaryUpdates<T> = ImmutableDictionary<T | Update<T> | Delete>;
+export type DictionaryUpdates<T> = ImmutableDictionary<T | Update<T> | Delete>;
 /** Update that can be applied to a dictionary object to add/remove/update its entries. */
 export declare class DictionaryUpdate<T> extends Update<ImmutableDictionary<T>> implements Iterable<Entry<string, T | Update<T> | Delete>> {
     /** Return a dictionary update with a specific entry marked for update. */

package/update/DictionaryUpdate.js

@@ -4,14 +4,11 @@ import { DictionarySchema } from "../schema/DictionarySchema.js";
 import { validate } from "../util/validate.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { isFeedback } from "../feedback/Feedback.js";
+import { getPrototype } from "../util/object.js";
 import { Update } from "./Update.js";
 import { Delete, DELETE } from "./Delete.js";
 /** Update that can be applied to a dictionary object to add/remove/update its entries. */
 export class DictionaryUpdate extends Update {
-    constructor(updates = {}) {
-        super();
-        this.updates = updates;
-    }
     /** Return a dictionary update with a specific entry marked for update. */
     static update(key, value) {
         return new DictionaryUpdate(isNullish(key) ? {} : { [key]: value });
@@ -20,12 +17,16 @@ export class DictionaryUpdate extends Update {
     static delete(key) {
         return new DictionaryUpdate(isNullish(key) ? {} : { [key]: DELETE });
     }
+    constructor(updates = {}) {
+        super();
+        this.updates = updates;
+    }
     /** Return a dictionary update with a specific entry marked for update. */
     update(key, value) {
         if (isNullish(key))
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             updates: { ...this.updates, [key]: value },
         };
@@ -35,7 +36,7 @@ export class DictionaryUpdate extends Update {
         if (isNullish(key))
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             updates: { ...this.updates, [key]: DELETE },
         };
@@ -49,7 +50,7 @@ export class DictionaryUpdate extends Update {
         if (!(validator instanceof DictionarySchema))
             return super.validate(validator);
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             updates: Object.fromEntries(_validateDictionaryUpdates(this.updates, validator.items)),
         };

package/util/array.d.ts

@@ -4,16 +4,16 @@ import { Matcher } from "./match.js";
  * Mutable array: an array that can be changed.
  * - Consistency with `MutableObject<T>` and `ImmutableArray<T>`
  */
-export declare type MutableArray<T = unknown> = T[];
+export type MutableArray<T = unknown> = T[];
 /**
  * Immutable array: an array that cannot be changed.
  * - Consistency with `ImmutableObject<T>` and `MutableArray<T>`
  */
-export declare type ImmutableArray<T = unknown> = readonly T[];
+export type ImmutableArray<T = unknown> = readonly T[];
 /** Get the type of the _items_ in an array. */
-export declare type ArrayItem<T extends ImmutableArray> = T[number];
+export type ArrayItem<T extends ImmutableArray> = T[number];
 /** Things that can be converted to arrays. */
-export declare type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
+export type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Is an unknown value an array? */
 export declare const isArray: <T extends ImmutableArray<unknown>>(v: unknown) => v is T;
 /** Assert that a value is an array. */

package/util/async.js

@@ -36,6 +36,11 @@ export function runMicrotasks() {
 }
 /** Type of `Promise` with `._resolve()` and `._reject()` methods available. */
 export class AbstractPromise extends Promise {
+    // Make `this.then()` create a `Promise` not a `Deferred`
+    // Done with a getter because some implementations implement this with a getter and we need to override it.
+    static get [Symbol.species]() {
+        return Promise;
+    }
     constructor() {
         let _resolve;
         let _reject;
@@ -46,14 +51,14 @@ export class AbstractPromise extends Promise {
         this._resolve = _resolve; // eslint-disable-line @typescript-eslint/no-non-null-assertion
         this._reject = _reject; // eslint-disable-line @typescript-eslint/no-non-null-assertion
     }
+}
+/** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
+export class Deferred extends Promise {
     // Make `this.then()` create a `Promise` not a `Deferred`
     // Done with a getter because some implementations implement this with a getter and we need to override it.
     static get [Symbol.species]() {
         return Promise;
     }
-}
-/** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
-export class Deferred extends Promise {
     constructor() {
         let resolve;
         let reject;
@@ -64,11 +69,6 @@ export class Deferred extends Promise {
         this.resolve = resolve; // eslint-disable-line @typescript-eslint/no-non-null-assertion
         this.reject = reject; // eslint-disable-line @typescript-eslint/no-non-null-assertion
     }
-    // Make `this.then()` create a `Promise` not a `Deferred`
-    // Done with a getter because some implementations implement this with a getter and we need to override it.
-    static get [Symbol.species]() {
-        return Promise;
-    }
 }
 /** Promise that resolves after a specified delay in milliseconds. */
 export class Delay extends AbstractPromise {

package/util/class.d.ts

@@ -1,10 +1,10 @@
 import { Arguments } from "./function.js";
 /** Class that has a public `constructor()` function. */
-export declare type Constructor<T, A extends Arguments> = new (...args: A) => T;
+export type Constructor<T, A extends Arguments> = new (...args: A) => T;
 /** Any function arguments (designed for use with `extends Arguments` guards). */
-export declare type AnyConstructor = new (...args: any) => any;
+export type AnyConstructor = new (...args: any) => any;
 /** Class prototype that can be used with `instanceof` (string name, as per `Function`, and a prototype field matching the object). */
-export declare type Class<T = unknown> = Function & {
+export type Class<T = unknown> = Omit<Function, "prototype"> & {
     prototype: T;
 };
 /** Is a given value a class constructor? */

package/util/clone.js

@@ -1,8 +1,9 @@
 import { isArray } from "./array.js";
 import { isData } from "./data.js";
 import { mapArray, mapObject } from "./transform.js";
+import { getPrototype } from "./object.js";
 /** Does an object implement `Cloneable` */
-export const isCloneable = (v) => isData(v) && typeof v.cloneable === "function";
+export const isCloneable = (v) => isData(v) && typeof v.clone === "function";
 /** Shallow clone a value. */
 export const shallowClone = (value) => value;
 /** Deep clone a value. */
@@ -20,7 +21,7 @@ export function cloneArray(input, recursor = shallowClone) {
     if (isCloneable(input))
         return input.clone();
     const output = mapArray(input, recursor);
-    Object.setPrototypeOf(output, Object.getPrototypeOf(input));
+    Object.setPrototypeOf(output, getPrototype(input));
     return output;
 }
 /** Clone an object. */
@@ -28,6 +29,6 @@ export function cloneObject(input, recursor = shallowClone) {
     if (isCloneable(input))
         return input.clone();
     const output = mapObject(input, recursor);
-    Object.setPrototypeOf(input, Object.getPrototypeOf(input));
+    Object.setPrototypeOf(input, getPrototype(input));
     return output;
 }

package/util/color.d.ts

@@ -1,8 +1,8 @@
 export declare const HEX3_REGEXP: RegExp;
 export declare const HEX6_REGEXP: RegExp;
 /** Things that can be converted to a `Color` instance. */
-export declare type PossibleColor = Color | string;
-export declare type PossibleOptionalColor = PossibleColor | null;
+export type PossibleColor = Color | string;
+export type PossibleOptionalColor = PossibleColor | null;
 /** Represent a color. */
 export declare class Color {
     /** Make a `Color` from a 3 or 6 or 8 byte hex string. */

package/util/color.js

@@ -7,12 +7,6 @@ export const HEX3_REGEXP = /^#?([0-F])([0-F])([0-F])$/i;
 export const HEX6_REGEXP = /^#?([0-F]{2})([0-F]{2})([0-F]{2})([0-F]{2})?$/i;
 /** Represent a color. */
 export class Color {
-    constructor(r = 255, g = 255, b = 255, a = 255) {
-        this.r = boundNumber(r, 0, 255);
-        this.g = boundNumber(g, 0, 255);
-        this.b = boundNumber(b, 0, 255);
-        this.a = boundNumber(a, 0, 255);
-    }
     /** Make a `Color` from a 3 or 6 or 8 byte hex string. */
     static fromHex(str) {
         const matches = (str.match(HEX3_REGEXP) || str.match(HEX6_REGEXP));
@@ -21,6 +15,12 @@ export class Color {
         const [, r, g, b, a] = matches;
         return new Color(_parse(r), _parse(g), _parse(b), typeof a === "string" ? _parse(a) : undefined);
     }
+    constructor(r = 255, g = 255, b = 255, a = 255) {
+        this.r = boundNumber(r, 0, 255);
+        this.g = boundNumber(g, 0, 255);
+        this.b = boundNumber(b, 0, 255);
+        this.a = boundNumber(a, 0, 255);
+    }
     /** Convert this color to a six or eight digit hex color. */
     get hex() {
         return `#${_hex(this.r)}${_hex(this.g)}${_hex(this.b)}${this.a < 255 ? _hex(this.a) : ""}`;

package/util/data.d.ts

@@ -1,18 +1,18 @@
 import type { ImmutableArray } from "./array.js";
 /** Data object. */
-export declare type Data = {
+export type Data = {
     readonly [K in string]: unknown;
 };
 /** Prop for a data object. */
-export declare type DataProp<T extends Data> = readonly [keyof T & string, T[keyof T & string]];
+export type DataProp<T extends Data> = readonly [keyof T & string, T[keyof T & string]];
 /** Key for a data object prop. */
-export declare type DataKey<T extends Data> = keyof T & string;
+export type DataKey<T extends Data> = keyof T & string;
 /** Value for a data object prop. */
-export declare type DataValue<T extends Data> = T[keyof T & string];
+export type DataValue<T extends Data> = T[keyof T & string];
 /** Data or `null` to indicate the data doesn't exist. */
-export declare type OptionalData<T extends Data> = T | null;
+export type OptionalData<T extends Data> = T | null;
 /** Set of named data objects. */
-export declare type Datas = {
+export type Datas = {
     readonly [K in string]: Data;
 };
 /** Is an unknown value a data object? */
@@ -24,15 +24,8 @@ export declare function getData<T extends Data>(result: OptionalData<T>): T;
 /** Get the props of a data object. */
 export declare function getDataProps<T extends Data>(data: T): ImmutableArray<DataProp<T>>;
 export declare function getDataProps<T extends Data>(data: T | Partial<T>): ImmutableArray<DataProp<T>>;
-/**
- * Format a data object as a string.
- * - Use the custom `.toString()` function if it exists (don't use built in `Object.prototype.toString` because it's useless.
- * - Use `.title` or `.name` or `.id` if they exist and are strings.
- * - Use `Object` otherwise.
- */
-export declare function formatData(data: Data): string;
 /** Type that represents an empty data object. */
-export declare type EmptyData = {
+export type EmptyData = {
     readonly [K in never]: never;
 };
 /** An empty object. */