@trpc/server 11.3.1 → 11.3.2-canary.4

package/dist/vendor/standard-schema-v1/spec.d.ts

@@ -1,60 +0,0 @@
-/**
- *
- * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
- */
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-export declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /** Validates unknown input values. */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The result interface of the validate function. */
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** The non-existent issues. */
-        readonly issues?: undefined;
-    }
-    /** The result interface if validation fails. */
-    interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard Schema types interface. */
-    interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Schema. */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-    /** Infers the output type of a Standard Schema. */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-}
-//# sourceMappingURL=spec.d.ts.map

package/dist/vendor/standard-schema-v1/spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../../src/vendor/standard-schema-v1/spec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,qCAAqC;AACrC,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,gDAAgD;IAChD,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,0CAA0C;QAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,sCAAsC;QACtC,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9C,iDAAiD;QACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;KACnD;IAED,qDAAqD;IACrD,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC;IAEnE,mDAAmD;IACnD,UAAiB,aAAa,CAAC,MAAM;QACnC,8BAA8B;QAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,+BAA+B;QAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;KAC7B;IAED,gDAAgD;IAChD,UAAiB,aAAa;QAC5B,uCAAuC;QACvC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KACvC;IAED,iDAAiD;IACjD,UAAiB,KAAK;QACpB,sCAAsC;QACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,qCAAqC;QACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;KACtE;IAED,+CAA+C;IAC/C,UAAiB,WAAW;QAC1B,2CAA2C;QAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;KAC3B;IAED,2CAA2C;IAC3C,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,oCAAoC;QACpC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QACtB,qCAAqC;QACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB;IAED,kDAAkD;IAClD,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAC;IAEX,mDAAmD;IACnD,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAC;CACb"}

package/dist/vendor/unpromise/index.d.ts

@@ -1,3 +0,0 @@
-export { Unpromise } from "./unpromise";
-export type { ProxyPromise, SubscribedPromise, PromiseExecutor, PromiseWithResolvers, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/vendor/unpromise/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vendor/unpromise/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/dist/vendor/unpromise/types.d.ts

@@ -1,28 +0,0 @@
-/** TYPES */
-/** A promise that exploits a single, memory-safe upstream subscription
- * to a single re-used Unpromise that persists for the VM lifetime of a
- * Promise.
- *
- * Calling unsubscribe() removes the subscription, eliminating
- * all references to the SubscribedPromise. */
-export interface SubscribedPromise<T> extends Promise<T> {
-    unsubscribe: () => void;
-}
-/** Duplicate of Promise interface, except each call returns SubscribedPromise */
-export interface ProxyPromise<T> extends Promise<T> {
-    subscribe: () => SubscribedPromise<T>;
-    then: <TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null) => SubscribedPromise<TResult1 | TResult2>;
-    catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null) => SubscribedPromise<T | TResult>;
-    finally: (onfinally?: (() => void) | null) => SubscribedPromise<T>;
-}
-export type PromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
-/** A standard pattern for a resolvable, rejectable Promise, based
- * on the emerging ES2023 standard. Type ported from
- * https://github.com/microsoft/TypeScript/pull/56593 */
-export interface PromiseWithResolvers<T> {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-}
-/** Given an array, this is the union of its members' types. */
-//# sourceMappingURL=types.d.ts.map

package/dist/vendor/unpromise/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vendor/unpromise/types.ts"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;;;8CAK8C;AAC9C,MAAM,WAAW,iBAAiB,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACtD,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,iFAAiF;AACjF,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACjD,SAAS,EAAE,MAAM,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAEtC,IAAI,EAAE,CAAC,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,KAAK,EACnC,WAAW,CAAC,EACR,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAChD,IAAI,EAER,UAAU,CAAC,EACP,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GACnD,IAAI,KAEL,iBAAiB,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC;IAE5C,KAAK,EAAE,CAAC,OAAO,GAAG,KAAK,EACrB,UAAU,CAAC,EACP,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,GACjD,IAAI,KAEL,iBAAiB,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;IAEpC,OAAO,EAAE,CACP,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,KAC5B,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAC3B;AAED,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAC/B,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,EAC5C,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,KAC3B,IAAI,CAAC;AAEV;;wDAEwD;AACxD,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC7C,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAChC;AAED,+DAA+D"}

package/dist/vendor/unpromise/unpromise.d.ts

@@ -1,121 +0,0 @@
-import type { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise } from "./types";
-/**
- * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
- * created once, cached and reused throughout the lifetime of the Promise. Get a
- * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
- *
- * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
- * `.then()` and `.catch()` just once. Promises derived from it use a
- * subscription- (and unsubscription-) based mechanism that monitors these
- * handlers.
- *
- * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
- * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
- * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
- * from the original, potentially long-lived Promise, eliminating memory leaks.
- *
- * This approach can eliminate the memory leaks that otherwise come about from
- * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
- * times on the same long-lived native Promise (subscriptions which can never be
- * cleaned up).
- *
- * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
- * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
- * the scenes, `resolve` is implemented simply as
- * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
- * to tidy up!
- *
- */
-export declare class Unpromise<T> implements ProxyPromise<T> {
-    /** INSTANCE IMPLEMENTATION */
-    /** The promise shadowed by this Unpromise<T>  */
-    protected readonly promise: Promise<T> | PromiseLike<T>;
-    /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-     * after the original promise settles - no further notifications will be issued. */
-    protected subscribers: ReadonlyArray<PromiseWithResolvers<T>> | null;
-    /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
-     * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-     * can be returned, and therefore subscription can be bypassed. */
-    protected settlement: PromiseSettledResult<T> | null;
-    /** Constructor accepts a normal Promise executor function like `new
-     * Unpromise((resolve, reject) => {...})` or accepts a pre-existing Promise
-     * like `new Unpromise(existingPromise)`. Adds `.then()` and `.catch()`
-     * handlers to the Promise. These handlers pass fulfilment and rejection
-     * notifications to downstream subscribers and maintains records of value
-     * or error if the Promise ever settles. */
-    protected constructor(promise: Promise<T>);
-    protected constructor(promise: PromiseLike<T>);
-    protected constructor(executor: PromiseExecutor<T>);
-    /** Create a promise that mitigates uncontrolled subscription to a long-lived
-     * Promise via .then() and .catch() - otherwise a source of memory leaks.
-     *
-     * The returned promise has an `unsubscribe()` method which can be called when
-     * the Promise is no longer being tracked by application logic, and which
-     * ensures that there is no reference chain from the original promise to the
-     * new one, and therefore no memory leak.
-     *
-     * If original promise has not yet settled, this adds a new unique promise
-     * that listens to then/catch events, along with an `unsubscribe()` method to
-     * detach it.
-     *
-     * If original promise has settled, then creates a new Promise.resolve() or
-     * Promise.reject() and provided unsubscribe is a noop.
-     *
-     * If you call `unsubscribe()` before the returned Promise has settled, it
-     * will never settle.
-     */
-    subscribe(): SubscribedPromise<T>;
-    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): SubscribedPromise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): SubscribedPromise<T | TResult>;
-    finally(onfinally?: (() => void) | null): SubscribedPromise<T>;
-    /** TOSTRING SUPPORT */
-    readonly [Symbol.toStringTag] = "Unpromise";
-    /** Unpromise STATIC METHODS */
-    /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
-     * of the provided Promise reference) */
-    static proxy<T>(promise: PromiseLike<T>): ProxyPromise<T>;
-    /** Create and store an Unpromise keyed by an original Promise. */
-    protected static createSubscribablePromise<T>(promise: PromiseLike<T>): Unpromise<T>;
-    /** Retrieve a previously-created Unpromise keyed by an original Promise. */
-    protected static getSubscribablePromise<T>(promise: PromiseLike<T>): ProxyPromise<T> | undefined;
-    /** Promise STATIC METHODS */
-    /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
-     * it (that can be later unsubscribed to eliminate Memory leaks) */
-    static resolve<T>(value: T | PromiseLike<T>): SubscribedPromise<Awaited<T>>;
-    /** Perform Promise.any() via SubscribedPromises, then unsubscribe them.
-     * Equivalent to Promise.any but eliminates memory leaks from long-lived
-     * promises accumulating .then() and .catch() subscribers. */
-    static any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
-    /** Perform Promise.race via SubscribedPromises, then unsubscribe them.
-     * Equivalent to Promise.race but eliminates memory leaks from long-lived
-     * promises accumulating .then() and .catch() subscribers. */
-    static race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
-    /** Create a race of SubscribedPromises that will fulfil to a single winning
-     * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
-     * accumulating .then() and .catch() subscribers. Allows simple logic to
-     * consume the result, like...
-     * ```ts
-     * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
-     * if(winner === promiseB){
-     *   const result = await promiseB;
-     *   // do the thing
-     * }
-     * ```
-     * */
-    static raceReferences<TPromise extends Promise<unknown>>(promises: readonly TPromise[]): Promise<readonly [TPromise]>;
-}
-/** Promises a 1-tuple containing the original promise when it resolves. Allows
- * awaiting the eventual Promise ***reference*** (easy to destructure and
- * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
- * may be ambiguous and therefore hard to identify as the winner of a race).
- * You can call unsubscribe on the Promise to mitigate memory leaks.
- * */
-export declare function resolveSelfTuple<TPromise extends Promise<unknown>>(promise: TPromise): SubscribedPromise<readonly [TPromise]>;
-//# sourceMappingURL=unpromise.d.ts.map

package/dist/vendor/unpromise/unpromise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unpromise.d.ts","sourceRoot":"","sources":["../../../src/vendor/unpromise/unpromise.ts"],"names":[],"mappings":"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"}

package/dist/vendor/unpromise/unpromise.js

@@ -1,292 +0,0 @@
-'use strict';
-
-/* eslint-disable @typescript-eslint/unbound-method */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-var _computedKey;
-/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
- * which is retained for the lifetime of the original Promise.
- */ const subscribableCache = new WeakMap();
-/** A NOOP function allowing a consistent interface for settled
- * SubscribedPromises (settled promises are not subscribed - they resolve
- * immediately). */ const NOOP = ()=>{
-// noop
-};
-_computedKey = Symbol.toStringTag;
-let _computedKey1 = _computedKey;
-/**
- * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
- * created once, cached and reused throughout the lifetime of the Promise. Get a
- * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
- *
- * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
- * `.then()` and `.catch()` just once. Promises derived from it use a
- * subscription- (and unsubscription-) based mechanism that monitors these
- * handlers.
- *
- * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
- * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
- * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
- * from the original, potentially long-lived Promise, eliminating memory leaks.
- *
- * This approach can eliminate the memory leaks that otherwise come about from
- * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
- * times on the same long-lived native Promise (subscriptions which can never be
- * cleaned up).
- *
- * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
- * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
- * the scenes, `resolve` is implemented simply as
- * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
- * to tidy up!
- *
- */ class Unpromise {
-    /** Create a promise that mitigates uncontrolled subscription to a long-lived
-   * Promise via .then() and .catch() - otherwise a source of memory leaks.
-   *
-   * The returned promise has an `unsubscribe()` method which can be called when
-   * the Promise is no longer being tracked by application logic, and which
-   * ensures that there is no reference chain from the original promise to the
-   * new one, and therefore no memory leak.
-   *
-   * If original promise has not yet settled, this adds a new unique promise
-   * that listens to then/catch events, along with an `unsubscribe()` method to
-   * detach it.
-   *
-   * If original promise has settled, then creates a new Promise.resolve() or
-   * Promise.reject() and provided unsubscribe is a noop.
-   *
-   * If you call `unsubscribe()` before the returned Promise has settled, it
-   * will never settle.
-   */ subscribe() {
-        // in all cases we will combine some promise with its unsubscribe function
-        let promise;
-        let unsubscribe;
-        const { settlement } = this;
-        if (settlement === null) {
-            // not yet settled - subscribe new promise. Expect eventual settlement
-            if (this.subscribers === null) {
-                // invariant - it is not settled, so it must have subscribers
-                throw new Error("Unpromise settled but still has subscribers");
-            }
-            const subscriber = withResolvers();
-            this.subscribers = listWithMember(this.subscribers, subscriber);
-            promise = subscriber.promise;
-            unsubscribe = ()=>{
-                if (this.subscribers !== null) {
-                    this.subscribers = listWithoutMember(this.subscribers, subscriber);
-                }
-            };
-        } else {
-            // settled - don't create subscribed promise. Just resolve or reject
-            const { status } = settlement;
-            if (status === "fulfilled") {
-                promise = Promise.resolve(settlement.value);
-            } else {
-                promise = Promise.reject(settlement.reason);
-            }
-            unsubscribe = NOOP;
-        }
-        // extend promise signature with the extra method
-        return Object.assign(promise, {
-            unsubscribe
-        });
-    }
-    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */ then(onfulfilled, onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.then(onfulfilled, onrejected), {
-            unsubscribe
-        });
-    }
-    catch(onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.catch(onrejected), {
-            unsubscribe
-        });
-    }
-    finally(onfinally) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.finally(onfinally), {
-            unsubscribe
-        });
-    }
-    /** Unpromise STATIC METHODS */ /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
-   * of the provided Promise reference) */ static proxy(promise) {
-        const cached = Unpromise.getSubscribablePromise(promise);
-        return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
-    }
-    /** Create and store an Unpromise keyed by an original Promise. */ static createSubscribablePromise(promise) {
-        const created = new Unpromise(promise);
-        subscribableCache.set(promise, created); // resolve promise to unpromise
-        subscribableCache.set(created, created); // resolve the unpromise to itself
-        return created;
-    }
-    /** Retrieve a previously-created Unpromise keyed by an original Promise. */ static getSubscribablePromise(promise) {
-        return subscribableCache.get(promise);
-    }
-    /** Promise STATIC METHODS */ /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
-   * it (that can be later unsubscribed to eliminate Memory leaks) */ static resolve(value) {
-        const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
-        return Unpromise.proxy(promise).subscribe();
-    }
-    static async any(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.any(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    static async race(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.race(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    /** Create a race of SubscribedPromises that will fulfil to a single winning
-   * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
-   * accumulating .then() and .catch() subscribers. Allows simple logic to
-   * consume the result, like...
-   * ```ts
-   * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
-   * if(winner === promiseB){
-   *   const result = await promiseB;
-   *   // do the thing
-   * }
-   * ```
-   * */ static async raceReferences(promises) {
-        // map each promise to an eventual 1-tuple containing itself
-        const selfPromises = promises.map(resolveSelfTuple);
-        // now race them. They will fulfil to a readonly [P] or reject.
-        try {
-            return await Promise.race(selfPromises);
-        } finally{
-            for (const promise of selfPromises){
-                // unsubscribe proxy promises when the race is over to mitigate memory leaks
-                promise.unsubscribe();
-            }
-        }
-    }
-    constructor(arg){
-        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property(this, "promise", void 0);
-        /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-   * after the original promise settles - no further notifications will be issued. */ _define_property(this, "subscribers", []);
-        /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
-   * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-   * can be returned, and therefore subscription can be bypassed. */ _define_property(this, "settlement", null);
-        /** TOSTRING SUPPORT */ _define_property(this, _computedKey1, "Unpromise");
-        // handle either a Promise or a Promise executor function
-        if (typeof arg === "function") {
-            this.promise = new Promise(arg);
-        } else {
-            this.promise = arg;
-        }
-        // subscribe for eventual fulfilment and rejection
-        // handle PromiseLike objects (that at least have .then)
-        const thenReturn = this.promise.then((value)=>{
-            // atomically record fulfilment and detach subscriber list
-            const { subscribers } = this;
-            this.subscribers = null;
-            this.settlement = {
-                status: "fulfilled",
-                value
-            };
-            // notify fulfilment to subscriber list
-            subscribers?.forEach(({ resolve })=>{
-                resolve(value);
-            });
-        });
-        // handle Promise (that also have a .catch behaviour)
-        if ("catch" in thenReturn) {
-            thenReturn.catch((reason)=>{
-                // atomically record rejection and detach subscriber list
-                const { subscribers } = this;
-                this.subscribers = null;
-                this.settlement = {
-                    status: "rejected",
-                    reason
-                };
-                // notify rejection to subscriber list
-                subscribers?.forEach(({ reject })=>{
-                    reject(reason);
-                });
-            });
-        }
-    }
-}
-/** Promises a 1-tuple containing the original promise when it resolves. Allows
- * awaiting the eventual Promise ***reference*** (easy to destructure and
- * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
- * may be ambiguous and therefore hard to identify as the winner of a race).
- * You can call unsubscribe on the Promise to mitigate memory leaks.
- * */ function resolveSelfTuple(promise) {
-    return Unpromise.proxy(promise).then(()=>[
-            promise
-        ]);
-}
-/** VENDORED (Future) PROMISE UTILITIES */ /** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */ function withResolvers() {
-    let resolve;
-    let reject;
-    const promise = new Promise((_resolve, _reject)=>{
-        resolve = _resolve;
-        reject = _reject;
-    });
-    return {
-        promise,
-        resolve,
-        reject
-    };
-}
-/** IMMUTABLE LIST OPERATIONS */ function listWithMember(arr, member) {
-    return [
-        ...arr,
-        member
-    ];
-}
-function listWithoutIndex(arr, index) {
-    return [
-        ...arr.slice(0, index),
-        ...arr.slice(index + 1)
-    ];
-}
-function listWithoutMember(arr, member) {
-    const index = arr.indexOf(member);
-    if (index !== -1) {
-        return listWithoutIndex(arr, index);
-    }
-    return arr;
-}
-
-exports.Unpromise = Unpromise;
-exports.resolveSelfTuple = resolveSelfTuple;