shelving 1.102.2 → 1.103.0

package/api/Resource.js

@@ -9,6 +9,12 @@ import { UNDEFINED_VALIDATOR } from "../util/validate.js";
  * @param returns The `Validator` the resource's returned value must conform to (defaults to `undefined` if not specified).
  */
 export class Resource {
+    /** Resource name.. */
+    name;
+    /** Payload validator. */
+    payload;
+    /** Result validator. */
+    result;
     constructor(name, payload = UNDEFINED_VALIDATOR, result = UNDEFINED_VALIDATOR) {
         this.name = name;
         this.payload = payload;
@@ -21,8 +27,7 @@ export class Resource {
      * @throws Feedback if the payload could not be validated.
      */
     prepare(unsafePayload) {
-        var _a;
-        return (_a = this.payload) === null || _a === void 0 ? void 0 : _a.validate(unsafePayload);
+        return this.payload?.validate(unsafePayload);
     }
     /**
      * Validate a result for this resource.

package/db/CollectionReference.js

@@ -3,6 +3,7 @@ import { AsyncItemReference, ItemReference } from "./ItemReference.js";
 import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
 class AbstractCollectionReference {
+    collection;
     constructor(collection) {
         this.collection = collection;
     }
@@ -29,6 +30,7 @@ class AbstractCollectionReference {
 }
 /** Reference to a collection in a synchronous provider. */
 export class CollectionReference extends AbstractCollectionReference {
+    provider;
     constructor(provider, collection) {
         super(collection);
         this.provider = provider;
@@ -75,6 +77,7 @@ export class CollectionReference extends AbstractCollectionReference {
 }
 /** Reference to a collection in an asynchronous provider. */
 export class AsyncCollectionReference extends AbstractCollectionReference {
+    provider;
     constructor(provider, collection) {
         super(collection);
         this.provider = provider;

package/db/Database.js

@@ -23,6 +23,7 @@ class AbstractDatabase {
 }
 /** Database with a synchronous provider. */
 export class Database extends AbstractDatabase {
+    provider;
     constructor(provider) {
         super();
         this.provider = provider;
@@ -57,6 +58,7 @@ export class Database extends AbstractDatabase {
 }
 /** Database with a synchronous provider. */
 export class AsyncDatabase extends AbstractDatabase {
+    provider;
     constructor(provider) {
         super();
         this.provider = provider;

package/db/ItemReference.js

@@ -13,6 +13,8 @@ export const getItemData = (id, data) => (data.id === id ? data : { ...data, id
 export const getItemQuery = (id) => ({ id, $limit: 1 });
 /** Reference to an item in a synchronous or asynchronous database. */
 class AbstractItemReference {
+    collection;
+    id;
     constructor(collection, id) {
         this.collection = collection;
         this.id = id;
@@ -44,6 +46,7 @@ class AbstractItemReference {
 }
 /** Reference to an item in a synchronous database. */
 export class ItemReference extends AbstractItemReference {
+    provider;
     constructor(provider, collection, id) {
         super(collection, id);
         this.provider = provider;
@@ -69,6 +72,7 @@ export class ItemReference extends AbstractItemReference {
 }
 /** Reference to an item in an asynchronous database. */
 export class AsyncItemReference extends AbstractItemReference {
+    provider;
     constructor(provider, collection, id) {
         super(collection, id);
         this.provider = provider;

package/db/ItemState.js

@@ -4,10 +4,13 @@ import { State } from "../state/State.js";
 import { call } from "../util/callback.js";
 import { NONE } from "../util/constants.js";
 import { getRequired } from "../util/optional.js";
+import { runSequence } from "../util/sequence.js";
 import { getOptionalSource } from "../util/source.js";
 import { getItemData } from "./ItemReference.js";
 /** Hold the current state of a item. */
 export class ItemState extends State {
+    ref;
+    busy = new BooleanState();
     /** Get the data of this state (throws `RequiredError` if item doesn't exist). */
     get data() {
         return getRequired(this.value);
@@ -21,14 +24,10 @@ export class ItemState extends State {
         return !!this.value;
     }
     constructor(ref) {
-        var _a;
         const { provider, collection, id } = ref;
-        const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+        const memory = getOptionalSource(CacheProvider, provider)?.memory;
         const time = memory ? memory.getItemTime(collection, id) : undefined;
         super(memory && typeof time === "number" ? memory.getItem(collection, id) : NONE, time);
-        this.busy = new BooleanState();
-        this._iterating = 0;
-        this._stop = undefined;
         this.ref = ref;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
@@ -59,7 +58,7 @@ export class ItemState extends State {
     }
     /** Subscribe this state to a provider. */
     connect(provider = this.ref.provider) {
-        return this.from(provider.getItemSequence(this.ref.collection, this.ref.id));
+        return runSequence(this.through(provider.getItemSequence(this.ref.collection, this.ref.id)));
     }
     // Override to subscribe to `MemoryProvider` while things are iterating over this state.
     async *[Symbol.asyncIterator]() {
@@ -74,14 +73,14 @@ export class ItemState extends State {
                 this.stop();
         }
     }
+    _iterating = 0;
     /** Start subscription to `MemoryProvider` if there is one. */
     start() {
-        var _a;
         if (!this._stop) {
             const { collection, id, provider } = this.ref;
-            const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+            const memory = getOptionalSource(CacheProvider, provider)?.memory;
             if (memory)
-                this._stop = this.from(memory.getCachedItemSequence(collection, id));
+                this._stop = runSequence(this.through(memory.getCachedItemSequence(collection, id)));
         }
     }
     /** Stop subscription to `MemoryProvider` if there is one. */
@@ -89,6 +88,7 @@ export class ItemState extends State {
         if (this._stop)
             this._stop = void call(this._stop);
     }
+    _stop = undefined;
     // Implement `Disposable`
     [Symbol.dispose]() {
         this.stop();

package/db/QueryReference.js

@@ -4,6 +4,8 @@ import { getRequired } from "../util/optional.js";
 import { runSequence } from "../util/sequence.js";
 /** Reference to a set of items in a sync or async provider. */
 class AbstractQueryReference {
+    collection;
+    query;
     constructor(collection, query = {}) {
         this.collection = collection;
         this.query = query;
@@ -27,6 +29,7 @@ class AbstractQueryReference {
 }
 /** Reference to a set of items in a provider. */
 export class QueryReference extends AbstractQueryReference {
+    provider;
     constructor(provider, collection, query) {
         super(collection, query);
         this.provider = provider;
@@ -61,6 +64,7 @@ export class QueryReference extends AbstractQueryReference {
 }
 /** Reference to a set of items in a provider. */
 export class AsyncQueryReference extends AbstractQueryReference {
+    provider;
     constructor(provider, collection, query) {
         super(collection, query);
         this.provider = provider;

package/db/QueryState.js

@@ -6,13 +6,18 @@ import { call } from "../util/callback.js";
 import { NONE } from "../util/constants.js";
 import { getRequired } from "../util/optional.js";
 import { getAfterQuery, getLimit } from "../util/query.js";
+import { runSequence } from "../util/sequence.js";
 import { getOptionalSource } from "../util/source.js";
 /** Hold the current state of a query. */
 export class QueryState extends State {
+    ref;
+    busy = new BooleanState();
+    limit;
     /** Can more items be loaded after the current result. */
     get hasMore() {
         return this._hasMore;
     }
+    _hasMore = false;
     /** Get the items currently stored in this query. */
     get items() {
         return this.value;
@@ -38,17 +43,12 @@ export class QueryState extends State {
         return this.value.length;
     }
     constructor(ref) {
-        var _a, _b;
         const { provider, collection, query } = ref;
-        const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+        const memory = getOptionalSource(CacheProvider, provider)?.memory;
         const time = memory ? memory.getQueryTime(collection, query) : undefined;
         super(memory && typeof time === "number" ? memory.getQuery(collection, query) : NONE, time);
-        this.busy = new BooleanState();
-        this._hasMore = false;
-        this._iterating = 0;
-        this._stop = undefined;
         this.ref = ref;
-        this.limit = (_b = getLimit(query)) !== null && _b !== void 0 ? _b : Infinity;
+        this.limit = getLimit(query) ?? Infinity;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
             this.refresh();
@@ -80,7 +80,7 @@ export class QueryState extends State {
     }
     /** Subscribe this state to a provider. */
     connect(provider = this.ref.provider) {
-        return this.from(provider.getQuerySequence(this.ref.collection, this.ref.query));
+        return runSequence(this.through(provider.getQuerySequence(this.ref.collection, this.ref.query)));
     }
     /**
      * Load more items after the last once.
@@ -120,14 +120,14 @@ export class QueryState extends State {
                 this.stop();
         }
     }
+    _iterating = 0;
     /** Start subscription to `MemoryProvider` if there is one. */
     start() {
-        var _a;
         if (!this._stop) {
             const { collection, query, provider } = this.ref;
-            const memory = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory;
+            const memory = getOptionalSource(CacheProvider, provider)?.memory;
             if (memory)
-                this._stop = this.from(memory.getCachedQuerySequence(collection, query));
+                this._stop = runSequence(this.through(memory.getCachedQuerySequence(collection, query)));
         }
     }
     /** Stop subscription to `MemoryProvider` if there is one. */
@@ -135,6 +135,7 @@ export class QueryState extends State {
         if (this._stop)
             this._stop = void call(this._stop);
     }
+    _stop = undefined;
     // Implement `Disposable`
     [Symbol.dispose]() {
         this.stop();

package/error/AssertionError.js

@@ -7,6 +7,8 @@ import { debug, indent } from "../util/debug.js";
  * @param expected The value that made the assertion fail.
  */
 export class AssertionError extends Error {
+    received;
+    expected;
     constructor(message = "Failed assertion", ...receivedExpected) {
         super(receivedExpected.length >= 2 //
             ? `${message}\nReceived:${indent(debug(receivedExpected[0]))}\nExpected:${indent(debug(receivedExpected[0]))}`

package/error/ThroughError.d.ts

@@ -3,6 +3,5 @@
  * - Merges the message and stack of the previous message.
  */
 export declare class ThroughError extends Error {
-    readonly cause: Error | unknown;
     constructor(message: string, cause: Error | unknown);
 }

package/feedback/Feedback.js

@@ -7,6 +7,10 @@
  * - `Feedback`: generated in reaction to something a user did, and helps them understand what to do next.
  */
 export class Feedback {
+    /** String feedback message that is safe to show to a user. */
+    message;
+    /** Nested details providing deeper feedback. */
+    value;
     constructor(feedback, value) {
         this.message = feedback;
         this.value = value;

package/feedback/Feedbacks.js

@@ -4,6 +4,8 @@ import { mapDictionary } from "../util/transform.js";
 import { Feedback } from "./Feedback.js";
 /** Feedback with a list of sub-feedbacks. */
 export class Feedbacks extends Feedback {
+    /** List of sub-feedbacks. */
+    feedbacks;
     /** List of sub-messages. */
     get messages() {
         return mapDictionary(this.feedbacks, getProp, "message");

package/firestore/client/FirestoreClientProvider.js

@@ -54,6 +54,7 @@ const _getFieldValue = ({ key, action, value }) => [key, action === "sum" ? incr
  * - Supports realtime subscriptions.
  */
 export class FirestoreClientProvider {
+    _firestore;
     constructor(firestore) {
         this._firestore = firestore;
     }

package/firestore/lite/FirestoreLiteProvider.js

@@ -51,6 +51,7 @@ const _getFieldValue = ({ key, action, value }) => [key, action === "sum" ? incr
  * - Does not support realtime subscriptions.
  */
 export class FirestoreLiteProvider {
+    _firestore;
     constructor(firestore) {
         this._firestore = firestore;
     }

package/firestore/server/FirestoreServerProvider.js

@@ -51,6 +51,7 @@ const _getFieldValue = ({ key, action, value }) => [key, action === "sum" ? Fiel
  * - Works with the Firebase Admin SDK for Node.JS
  */
 export class FirestoreServerProvider {
+    _firestore;
     constructor(firestore = new Firestore()) {
         this._firestore = firestore;
     }

package/iterate/AbstractGenerator.js

@@ -1,9 +1,6 @@
-var _a;
 /** Abstract generator designed to be extended that implements the full generator protocol. */
 export class AbstractGenerator {
-    constructor() {
-        this[_a] = "Generator";
-    }
+    [Symbol.toStringTag] = "Generator";
     throw(thrown) {
         // Default behaviour for a generator is to throw the error back out of the iterator and not continue.
         throw thrown;
@@ -13,7 +10,7 @@ export class AbstractGenerator {
         return { done: true, value };
     }
     // Implement `Iterable`
-    [(_a = Symbol.toStringTag, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this;
     }
 }

package/iterate/InspectGenerator.js

@@ -13,34 +13,31 @@ const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
  * 	console.log("RETURNED", watch.returned);
  */
 export class InspectGenerator extends ThroughGenerator {
-    constructor() {
-        super(...arguments);
-        /** Get the number of results received by this iterator so far. */
-        this.count = 0;
-        /** Is the iteration done? */
-        this.done = false;
-        this._first = _NOVALUE;
-        this._last = _NOVALUE;
-        this._returned = _NOVALUE;
-    }
+    /** Get the number of results received by this iterator so far. */
+    count = 0;
+    /** Is the iteration done? */
+    done = false;
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
             throw new ConditionError("Iteration not started");
         return this._first;
     }
+    _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
             throw new ConditionError("Iteration not started");
         return this._last;
     }
+    _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
             throw new ConditionError("Iteration not done");
         return this._returned;
     }
+    _returned = _NOVALUE;
     // Override to watch returned values.
     next(value) {
         return this._inspect(this.next(value));

package/iterate/ThroughGenerator.js

@@ -1,6 +1,7 @@
 import { AbstractGenerator } from "./AbstractGenerator.js";
 /** Iterable that pulls values from a source iterable. */
 export class ThroughGenerator extends AbstractGenerator {
+    _source;
     constructor(iterator) {
         super();
         this._source = iterator;

package/markup/regexp.js

@@ -30,11 +30,10 @@ export class WordRegExp extends RegExp {
         super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`, flags);
     }
     exec(input) {
-        var _a;
         const match = super.exec(input);
         if (match) {
             const { 0: zero, groups } = match;
-            const offset = ((_a = groups === null || groups === void 0 ? void 0 : groups.lookbehind) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            const offset = groups?.lookbehind?.length || 0;
             if (zero && offset) {
                 match[0] = zero.slice(offset); // Slice off the start of the match to remove the matched first character.
                 match.index += offset; // Increment the index to remove the matched first character.

package/markup/rule.js

@@ -1,5 +1,24 @@
 import { formatURL, getOptionalURL } from "../util/url.js";
 export class MarkupRule {
+    /**
+     * Contexts this rule should be applied in,
+     *
+     * @example `["block", "inline", "list"]`
+     */
+    contexts;
+    /**
+     * Context that children should be rendered with.
+     *
+     * @example `"inline"` // Children of the element rendered by this rule will be parsed against markup rules applied in the "inline" context.
+     */
+    subcontext;
+    /**
+     * Priority for this rule (defaults to zero).
+     *
+     * @example e.g. `<p>` rule is lower priority than other blocks so it matches last and paragraphs can be interrupted by e.g. `<ul>` and `<blockquote>`.
+     * @example e.g. `<code>` rule is higher priority than other inlines so e.g. `<strong>` or `<em>` don't match inside a code block.
+     */
+    priority;
     constructor(contexts, //
     subcontext = null, priority = 0) {
         this.contexts = contexts;
@@ -8,6 +27,8 @@ export class MarkupRule {
     }
 }
 export class RegExpMarkupRule extends MarkupRule {
+    regexp;
+    render;
     constructor(regexp, //
     render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
@@ -19,6 +40,8 @@ export class RegExpMarkupRule extends MarkupRule {
     }
 }
 export class NamedRegExpMarkupRule extends MarkupRule {
+    regexp;
+    render;
     constructor(regexp, //
     render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
@@ -30,6 +53,8 @@ export class NamedRegExpMarkupRule extends MarkupRule {
     }
 }
 export class LinkRegExpMarkupRule extends MarkupRule {
+    regexp;
+    render;
     constructor(regexp, //
     render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
@@ -46,7 +71,7 @@ export class LinkRegExpMarkupRule extends MarkupRule {
             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) } };
+                return { 0: first, index, groups: { href: url.href, title: title?.trim() || formatURL(url) } };
             }
         }
         return null;

package/markup/rules.js

@@ -118,7 +118,7 @@ getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>$
             key: null,
             ref: null,
             $$typeof,
-            props: { title: (title === null || title === void 0 ? void 0 : title.trim()) || undefined, children: code.trim() },
+            props: { title: title?.trim() || undefined, children: code.trim() },
         },
     },
 }), ["block", "list"], null, 10);

package/package.json

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

package/provider/CacheProvider.js

@@ -1,6 +1,8 @@
 import { MemoryProvider } from "./MemoryProvider.js";
 /** Keep a copy of asynchronous remote data in a local synchronous cache. */
 export class CacheProvider {
+    source;
+    memory;
     constructor(source, cache = new MemoryProvider()) {
         this.source = source;
         this.memory = cache;

package/provider/DebugProvider.js

@@ -30,6 +30,7 @@ class AbstractDebugProvider {
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export class DebugProvider extends AbstractDebugProvider {
+    source;
     constructor(source) {
         super();
         this.source = source;
@@ -133,6 +134,7 @@ export class DebugProvider extends AbstractDebugProvider {
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export class AsyncDebugProvider extends AbstractDebugProvider {
+    source;
     constructor(source) {
         super();
         this.source = source;

package/provider/MemoryProvider.js

@@ -13,10 +13,8 @@ import { updateData } from "../util/update.js";
  * - `get()` etc return the exact same instance of an object that's passed into `set()`
  */
 export class MemoryProvider {
-    constructor() {
-        /** List of tables in `{ collection: Table }` format. */
-        this._tables = {};
-    }
+    /** List of tables in `{ collection: Table }` format. */
+    _tables = {};
     /** Get a table for a collection. */
     getTable(collection) {
         return this._tables[collection] || (this._tables[collection] = new MemoryTable());
@@ -69,14 +67,12 @@ export class MemoryProvider {
 }
 /** An individual table of data. */
 export class MemoryTable {
-    constructor() {
-        /** Actual data in this table. */
-        this._data = new Map();
-        /** Times data was last updated. */
-        this._times = new Map();
-        /** Deferred sequence of next values. */
-        this._changed = new DeferredSequence();
-    }
+    /** Actual data in this table. */
+    _data = new Map();
+    /** Times data was last updated. */
+    _times = new Map();
+    /** Deferred sequence of next values. */
+    _changed = new DeferredSequence();
     getItemTime(id) {
         return this._times.get(id);
     }

package/provider/ThroughProvider.js

@@ -1,5 +1,6 @@
 /** A provider that passes through to a synchronous source. */
 export class ThroughProvider {
+    source;
     constructor(source) {
         this.source = source;
     }
@@ -39,6 +40,7 @@ export class ThroughProvider {
 }
 /** A provider that passes through to an asynchronous source. */
 export class AsyncThroughProvider {
+    source;
     constructor(source) {
         this.source = source;
     }

package/provider/ValidationProvider.js

@@ -9,6 +9,7 @@ const VALIDATION_CONTEXT_SET = { action: "set" };
 const VALIDATION_CONTEXT_UPDATE = { action: "update", partial: true };
 /** Validate a source provider (source can have any type because validation guarantees the type). */
 class BaseValidationProvider {
+    schemas;
     constructor(schemas) {
         this.schemas = schemas;
     }
@@ -28,6 +29,7 @@ class BaseValidationProvider {
 }
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationProvider extends BaseValidationProvider {
+    source;
     constructor(source, schemas) {
         super(schemas);
         this.source = source;
@@ -64,6 +66,7 @@ export class ValidationProvider extends BaseValidationProvider {
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export class AsyncValidationProvider extends BaseValidationProvider {
+    source;
     constructor(source, schemas) {
         super(schemas);
         this.source = source;

package/react/createCache.js

@@ -11,8 +11,7 @@ export function createCache() {
             return cache;
         },
         Cache: ({ children }) => {
-            var _a;
-            const cache = ((_a = useRef()).current || (_a.current = new Map()));
+            const cache = (useRef().current ||= new Map());
             return createElement(context.Provider, { children, value: cache });
         },
     };

package/react/useData.js

@@ -8,7 +8,7 @@ import { useState } from "./useState.js";
 const { Cache, useCache } = createCache();
 export function useData(ref) {
     const cache = useCache();
-    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
+    const key = ref?.toString();
     const state = ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItemReference ? new ItemState(ref) : new QueryState(ref)) : undefined;
     return useState(state);
 }

package/react/useFocus.js

@@ -17,16 +17,14 @@ export function useFocus(active = true) {
     const ref = useRef(null);
     // Effect that runs when element is first attached to the DOM.
     useEffect(() => {
-        var _a;
         // Set up a global listener the first time `useFocus()` is actually used.
         if (!FOCUS_STACK) {
             FOCUS_STACK = [];
             // Add a focus listener on the body that listens for changes in focus.
             document.body.addEventListener("focusin", () => {
-                var _a;
                 const el = getLastItem(FOCUS_STACK);
                 if (el && !el.contains(document.activeElement))
-                    (_a = getFirstFocusable(el)) === null || _a === void 0 ? void 0 : _a.focus();
+                    getFirstFocusable(el)?.focus();
             });
         }
         // Only run if the element is open and the ref is attached.
@@ -35,7 +33,7 @@ export function useFocus(active = true) {
             // Keep reference to the element that was focused before this element took the focus.
             const lastEl = document.activeElement;
             // Focus immediately on the first auto-focusable element now (e.g. this might just be the close button).
-            (_a = getFirstFocusable(el)) === null || _a === void 0 ? void 0 : _a.focus();
+            getFirstFocusable(el)?.focus();
             // Add this element to the stack of elements to keep focused.
             addArrayItem(FOCUS_STACK, el);
             return () => {

package/react/useInstance.js

@@ -6,11 +6,10 @@ import { isArrayEqual } from "../util/equal.js";
  * - Returns same instance for as long as `args` is equal to previous `args`.
  */
 export function useInstance(Constructor, ...args) {
-    var _a;
-    const internals = ((_a = useRef()).current || (_a.current = {
+    const internals = (useRef().current ||= {
         value: new Constructor(...args),
         args,
-    }));
+    });
     if (!isArrayEqual(args, internals.args)) {
         internals.value = new Constructor(...args);
         internals.args = args;