shelving 1.68.3 → 1.69.0

package/firestore/client/FirestoreClientProvider.js

@@ -38,15 +38,15 @@ function getCollection(firestore, { collection }) {
 }
 /** Create a corresponding `QueryReference` from a Query. */
 function getQuery(firestore, ref) {
-    const { sorts, filters, limit } = ref;
-    const constraints = [];
+    return firestoreQuery(getCollection(firestore, ref), ...yieldQueryConstraints(ref));
+}
+function* yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
-        constraints.push(firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]));
+        yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
-        constraints.push(firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value));
+        yield firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value);
     if (typeof limit === "number")
-        constraints.push(firestoreLimit(limit));
-    return firestoreQuery(getCollection(firestore, ref), ...constraints);
+        yield firestoreLimit(limit);
 }
 function getEntities(snapshot) {
     return snapshot.docs.map(getEntity);

package/firestore/lite/FirestoreLiteProvider.js

@@ -37,15 +37,15 @@ function getCollection(firestore, { collection }) {
 }
 /** Create a corresponding `QueryReference` from a Query. */
 function getQuery(firestore, ref) {
-    const { sorts, filters, limit } = ref;
-    const constraints = [];
+    return firestoreQuery(getCollection(firestore, ref), ...yieldQueryConstraints(ref));
+}
+function* yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
-        constraints.push(firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]));
+        yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
-        constraints.push(firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value));
+        yield firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value);
     if (typeof limit === "number")
-        constraints.push(firestoreLimit(limit));
-    return firestoreQuery(getCollection(firestore, ref), ...constraints);
+        yield firestoreLimit(limit);
 }
 function getEntities(snapshot) {
     return snapshot.docs.map(getEntity);

package/markup/rules.js

@@ -12,7 +12,7 @@ const MATCH_INDENT = /^ {1,2}/gm;
  */
 export const HEADING_RULE = {
     regexp: getLineRegExp(`(#{1,6}) +(${MATCH_LINE.source})`),
-    render: ([, prefix = "", children = ""]) => ({ type: `h${prefix.length}`, key: null, props: { children } }),
+    render: ([, prefix = "", children = ""]) => ({ type: `h${prefix.length}`, key: null, ref: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
 };
@@ -25,7 +25,7 @@ export const HEADING_RULE = {
  */
 export const HORIZONTAL_RULE = {
     regexp: getLineRegExp(`([${BULLETS}])(?: *\\1){2,}`),
-    render: () => ({ type: "hr", key: null, props: {} }),
+    render: () => ({ type: "hr", key: null, ref: null, props: {} }),
     contexts: ["block"],
 };
 /**
@@ -40,7 +40,7 @@ export const UNORDERED_LIST_RULE = {
     regexp: getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_UL_ITEMS).map(_mapUnorderedItem);
-        return { type: "ul", key: null, props: { children } };
+        return { type: "ul", key: null, ref: null, props: { children } };
     },
     contexts: ["block", "list"],
     childContext: "list",
@@ -48,7 +48,7 @@ export const UNORDERED_LIST_RULE = {
 const SPLIT_UL_ITEMS = new RegExp(`\\n+${UNORDERED}`, "g");
 const _mapUnorderedItem = (item, key) => {
     const children = item.replace(MATCH_INDENT, "");
-    return { type: "li", key, props: { children } };
+    return { type: "li", key, ref: null, props: { children } };
 };
 /**
  * Ordered list.
@@ -60,7 +60,7 @@ export const ORDERED_LIST_RULE = {
     regexp: getBlockRegExp(`(${ORDERED}${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_OL_ITEMS).map(_mapOrderedItem);
-        return { type: "ol", key: null, props: { children } };
+        return { type: "ol", key: null, ref: null, props: { children } };
     },
     contexts: ["block", "list"],
     childContext: "list",
@@ -73,7 +73,7 @@ const _mapOrderedItem = (item, key) => {
         .slice(firstSpace + 1)
         .trimStart()
         .replace(MATCH_INDENT, "");
-    return { type: "li", key, props: { value, children } };
+    return { type: "li", key, ref: null, props: { value, children } };
 };
 /**
  * Blockquote block.
@@ -86,6 +86,7 @@ export const BLOCKQUOTE_RULE = {
     render: ([, quote = ""]) => ({
         type: "blockquote",
         key: null,
+        ref: null,
         props: { children: quote.replace(BLOCKQUOTE_LINES, "") },
     }),
     contexts: ["block", "list"],
@@ -105,10 +106,12 @@ export const FENCED_CODE_RULE = {
     render: ([, , file, children]) => ({
         type: "pre",
         key: null,
+        ref: null,
         props: {
             children: {
                 type: "code",
                 key: null,
+                ref: null,
                 props: { "data-file": file || undefined, children },
             },
         },
@@ -121,7 +124,7 @@ export const FENCED_CODE_RULE = {
  */
 export const PARAGRAPH_RULE = {
     regexp: getBlockRegExp(` *(${MATCH_BLOCK.source})`),
-    render: ([, children]) => ({ type: `p`, key: null, props: { children } }),
+    render: ([, children]) => ({ type: `p`, key: null, ref: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
     priority: -10, // Lower precedence than other blocks so it matches last and paragraphs can be broken by other blocks.
@@ -152,6 +155,7 @@ export const LINK_RULE = {
     render: ([, title, href = ""], { rel }) => ({
         type: "a",
         key: null,
+        ref: null,
         props: { children: title || formatUrl(href), href, rel },
     }),
     contexts: ["inline", "list"],
@@ -182,6 +186,7 @@ export const AUTOLINK_RULE = {
     render: ([, href = "", title], { rel }) => ({
         type: "a",
         key: null,
+        ref: null,
         props: { children: title || formatUrl(href), href, rel },
     }),
     contexts: ["inline", "list"],
@@ -196,7 +201,7 @@ export const AUTOLINK_RULE = {
  */
 export const CODE_RULE = {
     regexp: getWrapRegExp("`+", MATCH_BLOCK.source),
-    render: ([, , children]) => ({ type: "code", key: null, props: { children } }),
+    render: ([, , children]) => ({ type: "code", key: null, ref: null, props: { children } }),
     contexts: ["inline", "list"],
     priority: 10, // Higher priority than other inlines so it matches first before e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
 };
@@ -210,7 +215,7 @@ export const CODE_RULE = {
  */
 export const STRONG_RULE = {
     regexp: getWrapRegExp("\\*+"),
-    render: ([, , children]) => ({ type: "strong", key: null, props: { children } }),
+    render: ([, , children]) => ({ type: "strong", key: null, ref: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
 };
@@ -224,7 +229,7 @@ export const STRONG_RULE = {
  */
 export const EMPHASIS_RULE = {
     regexp: getWrapRegExp("_+"),
-    render: ([, , children]) => ({ type: "em", key: null, props: { children } }),
+    render: ([, , children]) => ({ type: "em", key: null, ref: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
 };
@@ -238,7 +243,7 @@ export const EMPHASIS_RULE = {
  */
 export const INSERT_RULE = {
     regexp: getWrapRegExp("\\+\\++"),
-    render: ([, , children]) => ({ type: "ins", key: null, props: { children } }),
+    render: ([, , children]) => ({ type: "ins", key: null, ref: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
 };
@@ -252,7 +257,7 @@ export const INSERT_RULE = {
  */
 export const DELETE_RULE = {
     regexp: getWrapRegExp("--+|~~+"),
-    render: ([, , children]) => ({ type: "del", key: null, props: { children } }),
+    render: ([, , children]) => ({ type: "del", key: null, ref: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
 };
@@ -266,7 +271,7 @@ export const DELETE_RULE = {
  */
 export const LINEBREAK_RULE = {
     regexp: /\n/,
-    render: () => ({ type: "br", key: null, props: {} }),
+    render: () => ({ type: "br", key: null, ref: null, props: {} }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
 };

package/observe/Observable.d.ts

@@ -6,6 +6,8 @@ export declare type Unsubscribe = () => void;
 export interface Observable<T> {
     /** Subscribe an observer to this observable. */
     subscribe(observer: PartialObserver<T> | Dispatch<[T]>): Unsubscribe;
+    /** Is this observable closed? */
+    readonly closed?: boolean;
 }
 /** Subscribe function is a function that initiates a subscription to an observer. */
 export declare type Subscribe<T> = (observer: PartialObserver<T>) => Unsubscribe;
@@ -17,4 +19,6 @@ export declare function subscribe<T>(source: Subscribable<T>, target: PartialObs
 export interface Connectable<T> {
     /** Subscribe this entity to a subscribable. */
     connect(subscribable: Subscribable<T>): Unsubscribe;
+    /** Is this observable closed? */
+    readonly closed?: boolean;
 }

package/observe/Observable.js

@@ -1,7 +1,4 @@
-import { ConditionError } from "../error/ConditionError.js";
 /** Start a subscription to a `Subscribable` and return the `Unsubscriber` function. */
 export function subscribe(source, target) {
-    if (target.closed)
-        throw new ConditionError("Target is closed");
     return typeof source === "function" ? source(target) : source.subscribe(target);
 }

package/observe/Observer.d.ts

@@ -8,13 +8,13 @@ import type { Connectable } from "./Observable.js";
  * - Compatible with https://github.com/tc39/proposal-observable/
  */
 export interface Observer<T> {
-    /** Send the next value to this object. */
+    /** Send the next value to this observer. */
     readonly next: Dispatch<[T]>;
-    /** End this object with an error. */
+    /** End this observer with an error. */
     readonly error: Handler;
-    /** End this object with success. */
+    /** End this observer with success. */
     readonly complete: Dispatch;
-    /** Is this object closed? */
+    /** Is this observer closed? */
     readonly closed?: boolean;
 }
 /** Partial observer is an observer missing one or more of its callbacks. */

package/observe/Subject.d.ts

@@ -9,7 +9,7 @@ import { Observable, Subscribable, Unsubscribe } from "./Observable.js";
  */
 export declare class Subject<T> implements Observable<T>, ConnectableObserver<T> {
     /** List of sources this subject is subscribed to. */
-    protected readonly _cleanups: Set<Unsubscribe>;
+    protected readonly _connections: Set<Unsubscribe>;
     /** List of subscribed observers that values are forwarded to. */
     protected readonly _subscribers: Set<Partial<import("./Observer.js").Observer<T>>>;
     /** Get the number of current subscribers. */
@@ -25,16 +25,16 @@ export declare class Subject<T> implements Observable<T>, ConnectableObserver<T>
     complete(): void;
     /** Close this subject (called by `error()` and `complete()`). */
     private _close;
-    /** Connect this subjet to a source. */
+    /** Connect this subject to a source. */
     connect(source: Subscribable<T>): Unsubscribe;
     /** Disconnect this subject from all sources. */
     disconnect(): void;
     /**
      * Subscribe to this subject and return an unsubscriber function.
-     * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
+     * - Allows either an `Observer` object or  separate `next()", `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next: PartialObserver<T> | Dispatch<[T]>): Unsubscribe;
+    subscribe(target: PartialObserver<T> | Dispatch<[T]>): Unsubscribe;
     /** Add an observer (called by `subscribe()`). */
     protected _addObserver(observer: PartialObserver<T>): void;
     /** Called after adding the first observer. */

package/observe/Subject.js

@@ -11,7 +11,7 @@ import { subscribe } from "./Observable.js";
 export class Subject {
     constructor() {
         /** List of sources this subject is subscribed to. */
-        this._cleanups = new Set();
+        this._connections = new Set();
         /** List of subscribed observers that values are forwarded to. */
         this._subscribers = new Set();
         /** Is this subject open or closed (i.e. `error()` or `complete()` have been called. */
@@ -19,7 +19,7 @@ export class Subject {
     }
     /** Get the number of current subscribers. */
     get connections() {
-        return this._cleanups.size;
+        return this._connections.size;
     }
     /** Get the number of current subscribers. */
     get subscribers() {
@@ -27,7 +27,7 @@ export class Subject {
     }
     next(value) {
         if (this.closed)
-            throw new ConditionError("Subject is closed");
+            throw new ConditionError(`Observer is closed`);
         this._dispatch(value);
     }
     /** Call `next()` on the subscribers. */
@@ -37,7 +37,7 @@ export class Subject {
     }
     error(reason) {
         if (this.closed)
-            throw new ConditionError("Subject is closed");
+            throw new ConditionError(`Observer is closed`);
         this._close();
         for (const subscriber of this._subscribers) {
             this._subscribers.delete(subscriber);
@@ -46,7 +46,7 @@ export class Subject {
     }
     complete() {
         if (this.closed)
-            throw new ConditionError("Subject is closed");
+            throw new ConditionError(`Observer is closed`);
         this._close();
         for (const subscriber of this._subscribers) {
             this._subscribers.delete(subscriber);
@@ -58,38 +58,43 @@ export class Subject {
         this.closed = true;
         this.disconnect();
     }
-    /** Connect this subjet to a source. */
+    /** Connect this subject to a source. */
     connect(source) {
         if (this.closed)
-            throw new ConditionError("Subject is closed");
+            throw new ConditionError(`Connectable is closed`);
         const unsubscribe = subscribe(source, this);
         const cleanup = () => {
-            this._cleanups.delete(cleanup);
+            this._connections.delete(cleanup);
             dispatch(unsubscribe);
         };
-        this._cleanups.add(cleanup);
+        this._connections.add(cleanup);
         return cleanup;
     }
     /** Disconnect this subject from all sources. */
     disconnect() {
-        for (const cleanup of this._cleanups)
+        for (const cleanup of this._connections)
             dispatch(cleanup); // Cleanups are self-cleaning.
     }
     /**
      * Subscribe to this subject and return an unsubscriber function.
-     * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
+     * - Allows either an `Observer` object or  separate `next()", `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next) {
-        const observer = typeof next === "function" ? { next } : next;
+    subscribe(target) {
+        if (this.closed)
+            throw new ConditionError(`Observable is closed`);
+        const observer = typeof target === `function` ? { next: target } : target;
+        if (observer.closed)
+            throw new ConditionError("Target is closed");
         this._addObserver(observer);
         return this._removeObserver.bind(this, observer);
     }
     /** Add an observer (called by `subscribe()`). */
     _addObserver(observer) {
-        const size = this._subscribers.size;
+        const sizeBefore = this._subscribers.size;
         this._subscribers.add(observer);
-        if (!size && this._subscribers.size)
+        const sizeAfter = this._subscribers.size;
+        if (!sizeBefore && sizeAfter)
             this._addFirstObserver();
     }
     /** Called after adding the first observer. */
@@ -98,9 +103,10 @@ export class Subject {
     }
     /** Remove an observer. */
     _removeObserver(observer) {
-        const size = this._subscribers.size;
+        const sizeBefore = this._subscribers.size;
         this._subscribers.delete(observer);
-        if (size && !this._subscribers.size)
+        const sizeAfter = this._subscribers.size;
+        if (sizeBefore && !sizeAfter)
             this._removeLastObserver();
     }
     /** Called after adding the first observer. */

package/package.json

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

package/provider/DebugProvider.js

@@ -5,154 +5,154 @@ import { ThroughProvider } from "./ThroughProvider.js";
 /** Provider that logs its operations to the console for debugging purposes. */
 export class DebugProvider extends ThroughProvider {
     getDocument(ref) {
-        console.log(`Get "${ref}"`);
+        console.log(`Get ${ref}:`);
         try {
             const result = super.getDocument(ref);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error getting "${ref}"`, reason);
+                    console.error(`Error: Get ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error getting "${ref}"`, reason);
+            console.error(`Error: Get ${ref}:`, reason);
             throw reason;
         }
     }
     subscribeDocument(ref, observer) {
-        console.log(`Subscribe "${ref}"`);
+        console.log(`Subscribe ${ref}:`);
         return super.subscribeDocument(ref, new DatabaseDebugObserver(ref, observer));
     }
     addDocument(ref, data) {
-        console.log(`Add to "${ref}"`, data);
+        console.log(`Add ${ref}:`, data);
         try {
             const result = super.addDocument(ref, data);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error adding to "${ref}"`, reason);
+                    console.error(`Error: Add ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error adding to "${ref}"`, reason);
+            console.error(`Error: Add ${ref}:`, reason);
             throw reason;
         }
     }
     setDocument(ref, data) {
-        console.log(`Set "${ref}"`, data);
+        console.log(`Set ${ref}:`, data);
         try {
             const result = super.setDocument(ref, data);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error setting "${ref}"`, reason);
+                    console.error(`Error: Set ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error setting "${ref}"`, reason);
+            console.error(`Error: Set ${ref}:`, reason);
             throw reason;
         }
     }
     updateDocument(ref, update) {
-        console.log(`Update "${ref}"`, update.updates);
+        console.log(`Update ${ref}:`, update.updates);
         try {
             const result = super.updateDocument(ref, update);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error updating "${ref}"`, reason);
+                    console.error(`Error: Update ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error updating "${ref}"`, reason);
+            console.error(`Error: Update ${ref}:`, reason);
             throw reason;
         }
     }
     deleteDocument(ref) {
-        console.log(`Delete "${ref}"`);
+        console.log(`Delete ${ref}:`);
         try {
             const result = super.deleteDocument(ref);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error deleting "${ref}"`, reason);
+                    console.error(`Error: Delete ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error deleting "${ref}"`, reason);
+            console.error(`Error: Delete ${ref}:`, reason);
             throw reason;
         }
     }
     getQuery(ref) {
-        console.log(`Get "${ref}"`);
+        console.log(`Get ${ref}:`);
         try {
             const results = super.getQuery(ref);
             return isAsync(results)
                 ? results.then(undefined, reason => {
-                    console.error(`Error getting "${ref}"`, reason);
+                    console.error(`Error: Get ${ref}:`, reason);
                     throw reason;
                 })
                 : results;
         }
         catch (reason) {
-            console.error(`Error getting "${ref}"`, reason);
+            console.error(`Error: Get ${ref}:`, reason);
             throw reason;
         }
     }
     subscribeQuery(ref, observer) {
-        console.log(`Subscribe "${ref}"`);
+        console.log(`Subscribe ${ref}:`);
         return super.subscribeQuery(ref, new DatabaseDebugObserver(ref, observer));
     }
     setQuery(ref, data) {
-        console.log(`Set "${ref}"`, data);
+        console.log(`Set ${ref}:`, data);
         try {
             const result = super.setQuery(ref, data);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error setting "${ref}"`, reason);
+                    console.error(`Error: Set ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error setting "${ref}"`, reason);
+            console.error(`Error: Set ${ref}:`, reason);
             throw reason;
         }
     }
     updateQuery(ref, update) {
-        console.log(`Update "${ref}"`, update.updates);
+        console.log(`Update ${ref}:`, update.updates);
         try {
             const result = super.updateQuery(ref, update);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error updating "${ref}"`, reason);
+                    console.error(`Error: Update ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error updating "${ref}"`, reason);
+            console.error(`Error: Update ${ref}:`, reason);
             throw reason;
         }
     }
     deleteQuery(ref) {
-        console.log(`Delete "${ref}"`);
+        console.log(`Delete ${ref}:`);
         try {
             const result = super.deleteQuery(ref);
             return isAsync(result)
                 ? result.then(undefined, reason => {
-                    console.error(`Error writing "${ref}"`, reason);
+                    console.error(`Error: Delete ${ref}:`, reason);
                     throw reason;
                 })
                 : result;
         }
         catch (reason) {
-            console.error(`Error writing "${ref}"`, reason);
+            console.error(`Error: Delete ${ref}:`, reason);
             throw reason;
         }
     }

package/react/useSubscribe.js

@@ -12,5 +12,12 @@ import { BLACKHOLE } from "../util/function.js";
  */
 export function useSubscribe(subscribable) {
     const setState = useState(subscribable instanceof State && !subscribable.loading ? subscribable.value : NOVALUE)[1];
-    useEffect(subscribable ? () => subscribe(subscribable, { next: setState, error: setState }) : BLACKHOLE, [subscribable]);
+    useEffect(subscribable
+        ? () => {
+            // If the subscribable is an observer, only subscribe if the subscribable isn't closed.
+            // Otherwise `subscribe()` is likely to throw a `Observer is closed` error.
+            if (typeof subscribable === "function" || !subscribable.closed)
+                return subscribe(subscribable, { next: setState, error: setState });
+        }
+        : BLACKHOLE, [subscribable]);
 }

package/state/SelfClosingState.js

@@ -18,7 +18,10 @@ export class SelfClosingState extends State {
 export class DelayedSelfClosingState extends State {
     constructor(delay, ...args) {
         super(...args);
-        this._timeout = new Timeout(delay);
+        this._timeout = new Timeout(() => {
+            if (!this.closed)
+                this.complete();
+        }, delay);
     }
     // Override to clear the timeout when an observer is added.
     _addFirstObserver() {
@@ -26,9 +29,6 @@ export class DelayedSelfClosingState extends State {
     }
     // Override to close this state when the last observer is removed.
     _removeLastObserver() {
-        this._timeout.set(() => {
-            if (!this.closed)
-                this.complete();
-        });
+        this._timeout.set();
     }
 }

package/util/async.js

@@ -69,7 +69,7 @@ export async function callAsyncParallel(callback, items, ...args) {
 // Internal way for us to save `resolve()` and `reject()` from a new Promise used by `Deferred` and `ExtendablePromise`
 let resolve; // eslint-disable-line @typescript-eslint/no-explicit-any
 let reject;
-function saveResolveReject(x, // eslint-disable-line @typescript-eslint/no-explicit-any
+function _saveResolveReject(x, // eslint-disable-line @typescript-eslint/no-explicit-any
 y) {
     resolve = x;
     reject = y;
@@ -77,7 +77,7 @@ y) {
 /** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
 export class Deferred extends Promise {
     constructor() {
-        super(saveResolveReject);
+        super(_saveResolveReject);
         this.resolve = resolve;
         this.reject = reject;
     }
@@ -90,7 +90,7 @@ export class Deferred extends Promise {
 /** Type of `Promise` with `._resolve()` and `._reject()` methods available. */
 export class AbstractPromise extends Promise {
     constructor() {
-        super(saveResolveReject);
+        super(_saveResolveReject);
         this._resolve = resolve;
         this._reject = reject;
     }

package/util/jsx.d.ts

@@ -11,6 +11,7 @@ export declare type JSXElement<P extends JSXProps = JSXProps> = {
     type: string | JSXElementCreator<P>;
     props: P;
     key: string | number | null;
+    ref: null;
     $$typeof?: symbol;
 };
 /** JSX node (similar to `React.ReactNode`) */

package/util/timeout.d.ts

@@ -1,3 +1,4 @@
+import type { Dispatch } from "./function.js";
 /**
  * Create a new Timeout.
  *
@@ -9,9 +10,10 @@
  * @param ms The default delay for any created timeouts (in ms).
  */
 export declare class Timeout {
+    private _callback;
     private _ms;
     private _timeout;
-    constructor(ms?: number);
+    constructor(callback?: Dispatch | null, ms?: number);
     /** Is a timeout currently set? */
     get exists(): boolean;
     /**
@@ -19,7 +21,8 @@ export declare class Timeout {
      * @param callback
      * @param ms The delay for this timeout (in ms).
      */
-    set(callback: () => void, ms?: number): void;
+    set(callback?: Dispatch | null, ms?: number): void;
+    private _run;
     /** Cancel any existing timeout.. */
     clear(): void;
 }

package/util/timeout.js

@@ -9,8 +9,14 @@
  * @param ms The default delay for any created timeouts (in ms).
  */
 export class Timeout {
-    constructor(ms = 0) {
-        this._timeout = undefined;
+    constructor(callback = null, ms = 0) {
+        this._timeout = null;
+        this._run = () => {
+            this._timeout = null;
+            if (this._callback)
+                this._callback();
+        };
+        this._callback = callback;
         this._ms = ms;
     }
     /** Is a timeout currently set? */
@@ -22,16 +28,22 @@ export class Timeout {
      * @param callback
      * @param ms The delay for this timeout (in ms).
      */
-    set(callback, ms = this._ms) {
+    set(callback = this._callback, ms = this._ms) {
         this.clear();
-        this._timeout = setTimeout(() => {
-            this._timeout = undefined;
-            callback();
-        }, ms);
+        this._timeout = setTimeout(_executeTimeout, ms, this, callback);
     }
     /** Cancel any existing timeout.. */
     clear() {
-        if (this._timeout)
-            this._timeout = void clearTimeout(this._timeout);
+        const timeout = this._timeout;
+        if (timeout) {
+            this._timeout = null;
+            clearTimeout(timeout);
+        }
     }
 }
+/** Actually execute the timeout. */
+function _executeTimeout(timeout, callback) {
+    timeout.clear();
+    if (callback)
+        callback();
+}