shelving 1.86.1 → 1.86.2

package/markup/rules.js

@@ -1,7 +1,7 @@
 /* eslint-disable import/export */
 import { getRegExp } from "../util/regexp.js";
-import { formatURL, getOptionalURL } from "../util/url.js";
 import { getBlockRegExp, getLineRegExp, BLOCK_REGEXP, LINE_REGEXP, WordRegExp } from "./regexp.js";
+import { LinkRegExpMarkupRule, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
 /** React security symbol — see https://github.com/facebook/react/pull/4832 */
 const $$typeof = Symbol.for("react.element");
 /**
@@ -10,18 +10,13 @@ const $$typeof = Symbol.for("react.element");
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const HEADING_RULE = {
-    match: getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`),
-    render: ({ prefix, heading }) => ({
-        type: `h${prefix.length}`,
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: heading.trim() },
-    }),
-    contexts: ["block"],
-    subcontext: "inline",
-};
+export const HEADING_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
+    type: `h${prefix.length}`,
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: heading.trim() },
+}), ["block"], "inline");
 /**
  * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
@@ -29,17 +24,13 @@ export const HEADING_RULE = {
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const SEPARATOR_RULE = {
-    match: getLineRegExp("([-*•+_=])(?: *\\1){2,}"),
-    render: () => ({
-        type: "hr",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {},
-    }),
-    contexts: ["block"],
-};
+export const SEPARATOR_RULE = new RegExpMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
+    type: "hr",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {},
+}), ["block"]);
 /**
  * Unordered list.
  * - Roughly the same syntax as Markdown (might be some differences with indenting).
@@ -50,18 +41,13 @@ export const SEPARATOR_RULE = {
 const UNORDERED_PREFIX = "[-*•+] +";
 const UNORDERED_SPLIT = new RegExp(`(?:^|\n)+${UNORDERED_PREFIX}`, "g");
 const UNORDERED_INDENT = /^\t/gm;
-export const UNORDERED_RULE = {
-    match: getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`),
-    render: ({ list }) => ({
-        type: "ul",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: list.split(UNORDERED_SPLIT).filter(Boolean).map(_mapUnordered) },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "list",
-};
+export const UNORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+    type: "ul",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: list.split(UNORDERED_SPLIT).filter(Boolean).map(_mapUnordered) },
+}), ["block", "list"], "list");
 const _mapUnordered = (item, key) => ({
     type: "li",
     key,
@@ -77,18 +63,13 @@ const _mapUnordered = (item, key) => ({
 const ORDERED_PREFIX = "[1-9][0-9]{0,8}[.):] +"; // Number for a numbered list, e.g. `1.` or `2)` or `3:`
 const ORDERED_SPLIT = new RegExp(`\n+(?=${ORDERED_PREFIX})`, "g");
 const ORDERED_INDENT = UNORDERED_INDENT;
-export const ORDERED_RULE = {
-    match: getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`),
-    render: ({ list }) => ({
-        type: "ol",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "list",
-};
+export const ORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+    type: "ol",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
+}), ["block", "list"], "list");
 const _mapOrdered = (item, key) => ({
     type: "li",
     key,
@@ -110,18 +91,13 @@ const _mapOrdered = (item, key) => ({
  */
 const BLOCKQUOTE_PREFIX = "> *";
 const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
-export const BLOCKQUOTE_RULE = {
-    match: getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`),
-    render: ({ quote }) => ({
-        type: "blockquote",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "block",
-};
+export const BLOCKQUOTE_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`), ({ quote }) => ({
+    type: "blockquote",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
+}), ["block", "list"], "block");
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -129,62 +105,42 @@ export const BLOCKQUOTE_RULE = {
  * - 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 easier to use).
  */
-export const FENCED_CODE_RULE = {
-    // Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
-    match: getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`),
-    render: ({ title, code }) => ({
-        type: "pre",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {
-            children: {
-                type: "code",
-                key: null,
-                ref: null,
-                $$typeof,
-                props: { title: (title === null || title === void 0 ? void 0 : title.trim()) || undefined, children: code.trim() },
-            },
+export const FENCED_CODE_RULE = new NamedRegExpMarkupRule(
+// Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
+getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`), ({ title, code }) => ({
+    type: "pre",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {
+        children: {
+            type: "code",
+            key: null,
+            ref: null,
+            $$typeof,
+            props: { title: (title === null || title === void 0 ? void 0 : title.trim()) || undefined, children: code.trim() },
         },
-    }),
-    contexts: ["block", "list"],
-    priority: 10, // Higher priority than other blocks so e.g. lists inside fenced code don't become lists.
-};
+    },
+}), ["block", "list"], null, 10);
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export const PARAGRAPH_RULE = {
-    match: getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`),
-    render: ({ paragraph }) => ({
-        type: `p`,
+export const PARAGRAPH_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
+    type: `p`,
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: paragraph.trim() },
+}), ["block"], "inline", -10);
+/** Render function for URL and LINK rules. */
+export function renderLinkRule({ href, title }, { rel }) {
+    return {
+        type: "a",
         key: null,
         ref: null,
         $$typeof,
-        props: { children: paragraph.trim() },
-    }),
-    contexts: ["block"],
-    subcontext: "inline",
-    priority: -10, // Lower precedence than other blocks so it matches last and paragraphs can be broken by other blocks.
-};
-/**
- * Function that checks a link against the schemas allowed by rendering.
- * - Used by `URL_RULE~ and `LINK_RULE`
- * - Validates that the link is a valid URL (using `getOptionalURL()` to resolve relative links relative to `options.url`).
- * - Validates that the link's URL scheme is in the `options.schemes` whitelist (defaults to `http` and `https`).
- * - Generates a default title for the link using `formatURL()` (e.g. `shax.com/my/dir`).
- */
-export function getLinkMatcher(regexp) {
-    return (input, { schemes, url: base }) => {
-        const match = regexp.exec(input);
-        if (match) {
-            const { 0: first, index, groups } = match;
-            const { href, title } = groups;
-            const url = getOptionalURL(href, base);
-            if (url && schemes.includes(url.protocol)) {
-                return { 0: first, index, groups: { href: url.href, title: (title === null || title === void 0 ? void 0 : title.trim()) || formatURL(url) } };
-            }
-        }
+        props: { children: title, href, rel },
     };
 }
 /**
@@ -195,18 +151,7 @@ export function getLinkMatcher(regexp) {
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export const URL_REGEXP = getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/);
-export const URL_RULE = {
-    match: getLinkMatcher(URL_REGEXP),
-    render: ({ href, title }, { rel }) => ({
-        type: "a",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: title, href, rel },
-    }),
-    contexts: ["inline", "list"],
-    subcontext: "link",
-};
+export const URL_RULE = new LinkRegExpMarkupRule(URL_REGEXP, renderLinkRule, ["inline", "list"], "link");
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -216,10 +161,7 @@ export const URL_RULE = {
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
 export const LINK_REGEXP = getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
-export const LINK_RULE = {
-    ...URL_RULE,
-    match: getLinkMatcher(LINK_REGEXP),
-};
+export const LINK_RULE = new LinkRegExpMarkupRule(LINK_REGEXP, renderLinkRule, ["inline", "list"], "link");
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -227,18 +169,13 @@ export const LINK_RULE = {
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = {
-    match: new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`),
-    render: ({ code }) => ({
-        type: "code",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: code },
-    }),
-    contexts: ["inline", "list"],
-    priority: 10, // Higher priority than e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
-};
+export const CODE_RULE = new NamedRegExpMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
+    type: "code",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: code },
+}), ["inline", "list"], null, 10);
 /**
  * Inline strong, emphasis, insert, delete, highlight.
  * - Inline strong text wrapped in one or more `*` asterisks.
@@ -253,18 +190,14 @@ export const CODE_RULE = {
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
 const INLINE_CHARS = { "-": "del", "~": "del", "+": "ins", "*": "strong", "_": "em", "=": "mark", ":": "mark" }; // Hyphen must be first so it works when we use the keys as a character class.
-export const INLINE_RULE = {
-    match: new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`),
-    render: ({ char, text }) => ({
-        type: INLINE_CHARS[char],
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: text },
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
+export const INLINE_RULE = new NamedRegExpMarkupRule(new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`), // prettier-ignore
+({ char, text }) => ({
+    type: INLINE_CHARS[char],
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: text },
+}), ["inline", "list", "link"], "inline");
 /**
  * Hard linebreak (`<br />` tag).
  * - Any line break in a paragraph will become a hard `<br />` tag.
@@ -273,18 +206,13 @@ export const INLINE_RULE = {
  *   - 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 = {
-    match: /\n/,
-    render: () => ({
-        type: "br",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {},
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
+export const LINEBREAK_RULE = new RegExpMarkupRule(/\n/, () => ({
+    type: "br",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {},
+}), ["inline", "list", "link"], "inline");
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.86.1",
+	"version": "1.86.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -43,7 +43,7 @@
 	"sideEffects": false,
 	"engineStrict": true,
 	"engines": {
-		"node": ">=14.0.0"
+		"node": ">=16.0.0"
 	},
 	"scripts": {
 		"fix": "npm run fix:prettier && npm run fix:eslint",
@@ -64,26 +64,26 @@
 		"build:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config=jest.config.build.cjs"
 	},
 	"devDependencies": {
-		"@google-cloud/firestore": "^6.4.1",
-		"@types/jest": "^29.2.3",
-		"@types/react": "^18.0.25",
-		"@types/react-dom": "^18.0.9",
-		"@typescript-eslint/eslint-plugin": "^5.44.0",
-		"@typescript-eslint/parser": "^5.44.0",
-		"dpdm": "^3.9.0",
-		"esbuild": "^0.15.14",
+		"@google-cloud/firestore": "^6.4.2",
+		"@types/jest": "^29.4.0",
+		"@types/react": "^18.0.27",
+		"@types/react-dom": "^18.0.10",
+		"@typescript-eslint/eslint-plugin": "^5.49.0",
+		"@typescript-eslint/parser": "^5.49.0",
+		"dpdm": "^3.11.0",
+		"esbuild": "^0.15.18",
 		"esbuild-jest": "^0.5.0",
-		"eslint": "^8.28.0",
-		"eslint-config-prettier": "^8.5.0",
-		"eslint-plugin-import": "^2.26.0",
+		"eslint": "^8.33.0",
+		"eslint-config-prettier": "^8.6.0",
+		"eslint-plugin-import": "^2.27.5",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.14.0",
-		"jest": "^29.3.1",
+		"firebase": "^9.16.0",
+		"jest": "^29.4.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"prettier": "^2.8.0",
+		"prettier": "^2.8.3",
 		"react": "^18.1.0",
 		"react-dom": "^18.1.0",
-		"typescript": "^4.9.3"
+		"typescript": "^4.9.4"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=4.0.0",

package/react/useItem.js

@@ -18,9 +18,9 @@ export class ItemState extends State {
         return !!this.value;
     }
     constructor(ref) {
-        var _a;
         const { db, collection, id } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, db.provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
+        const cache = getOptionalSource(CacheProvider, db.provider);
+        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
         const time = table ? table.getItemTime(id) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getItem(id) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedItemSequence(id))) : undefined);

package/react/useQuery.js

@@ -38,9 +38,9 @@ export class QueryState extends State {
         return this.value.length;
     }
     constructor(ref) {
-        var _a;
         const { db, collection, limit } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, db.provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
+        const cache = getOptionalSource(CacheProvider, db.provider);
+        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
         const time = table ? table.getQueryTime(ref) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getQuery(ref) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedQuerySequence(ref))) : undefined);

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/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,5 +1,6 @@
 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. */
@@ -20,7 +21,7 @@ export class ArrayUpdate extends Update {
     /** 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.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";
@@ -49,7 +50,7 @@ export class DataUpdate extends Update {
         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.js

@@ -4,6 +4,7 @@ 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. */
@@ -25,7 +26,7 @@ export class DictionaryUpdate extends Update {
         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/class.d.ts

@@ -4,7 +4,7 @@ export type Constructor<T, A extends Arguments> = new (...args: A) => T;
 /** Any function arguments (designed for use with `extends Arguments` guards). */
 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 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/data.d.ts

@@ -24,13 +24,6 @@ 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 type EmptyData = {
     readonly [K in never]: never;

package/util/data.js

@@ -13,25 +13,7 @@ export function getData(result) {
 export function getDataProps(data) {
     return Object.entries(data);
 }
-/**
- * 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 function formatData(data) {
-    const { toString, name, title, id } = data;
-    if (typeof toString === "function" && toString !== Object.prototype.toString)
-        return data.toString();
-    if (typeof name === "string")
-        return name;
-    if (typeof title === "string")
-        return title;
-    if (typeof id === "string")
-        return id;
-    return "Object";
-}
 /** An empty object. */
-export const EMPTY_DATA = {};
+export const EMPTY_DATA = { __proto__: null };
 /** Function that returns an an empty object. */
 export const getEmptyData = () => EMPTY_DATA;

package/util/date.d.ts

@@ -35,7 +35,7 @@ export declare const getYMD: (possible?: PossibleDate) => string;
 /** List of day-of-week strings. */
 export declare const days: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 /** Type listing day-of-week strings. */
-export type Day = typeof days[number];
+export type Day = (typeof days)[number];
 /** Convert a `Date` instance to a day-of-week string like "monday" */
 export declare const getDay: (target?: PossibleDate) => Day;
 /** Get a Date representing exactly midnight of the specified date. */