@trpc/server 11.1.3-alpha-tmp-tsdown.23 → 11.1.3-alpha-tmp-tsdown.26

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

@@ -1,64 +0,0 @@
-//#region src/vendor/standard-schema-v1/spec.d.ts
-/**
- *
- * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
- */
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-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'];
-} //#endregion
-
-//# sourceMappingURL=spec.d.ts.map
-export { StandardSchemaV1 };
-//# sourceMappingURL=spec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"spec.d.ts","names":[],"sources":["../../../src/vendor/standard-schema-v1/spec.ts"],"sourcesContent":[],"mappings":";;;;;;UASiB,2CAA2C;EAA3C;EAAgB,SAAA,WAAA,EAET,gBAAA,CAAiB,KAFR,CAEc,KAFd,EAEqB,MAFrB,CAAA;;AAEc,kBAGtB,gBAAA,CAHsB;EAAK;EAAQ,UAApC,KAAA,CAAA,QAAiB,OAAA,EAAA,SAKU,KALV,CAAA,CAAA;IAAK;IAGrB,SAAA,OAAgB,EAAA,CAAA;IAAA;IAEU,SAAA,MAAA,EAAA,MAAA;IAQnC;IAAP,SAAA,QAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,MAAA,CAAO,MAAP,CAAA,GAAiB,OAAjB,CAAyB,MAAzB,CAAgC,MAAhC,CAAA,CAAA;IAAgC;IAAP,SAAA,KAAA,CAAA,EAEb,KAFa,CAEP,KAFO,EAEA,MAFA,CAAA,GAAA,SAAA;EAAM;EAAP;EAED,KAAE,MAAA,CAAA,MAAA,CAAA,GAIH,aAJG,CAIW,MAJX,CAAA,GAIqB,aAJrB;EAAM;EAAd,UAImB,aAAA,CAAA,MAAA,CAAA,CAAA;IAAd;IAAwB,SAAA,KAAA,EAKnC,MALmC;IAKnC;IAQe,SAAA,MAAA,CAAA,EAAA,SAAA;EAAK;EAAN;EAQW,UAAG,aAAA,CAAA;IAA5B;IAMF,SAAA,MAAA,EAdG,aAcH,CAdiB,KAcjB,CAAA;EAAW;EAI2B;EAE/B,UAEJ,KAAA,CAAA;IAImB;IACpC,SAAA,OAAA,EAAA,MAAA;IADwD;IAKnB,SAAA,IAAA,CAAA,EAvBrB,aAuBqB,CAvBP,WAuBO,GAvBO,WAuBP,CAAA,GAAA,SAAA;EAAgB;EAC/C;EAD8D,UAAA,WAAA,CAAA;;kBAjBtD;;;4CAIiC;;oBAE/B;;qBAEC;;;iCAImB,oBAAoB,YACxD;;kCAIqC,oBAAoB,YACzD"}

package/dist/vendor/unpromise/index.js

@@ -1 +0,0 @@
-const require__Users_julius_dev_trpc_packages_server_src_vendor_unpromise_unpromise = require('./unpromise.js');

package/dist/vendor/unpromise/index.mjs

@@ -1 +0,0 @@
-import { Unpromise } from "./unpromise.mjs";

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

@@ -1,34 +0,0 @@
-//#region src/vendor/unpromise/types.d.ts
-/** 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. */
-interface SubscribedPromise<T> extends Promise<T> {
-  unsubscribe: () => void;
-}
-/** Duplicate of Promise interface, except each call returns SubscribedPromise */
-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>;
-}
-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 */
-interface PromiseWithResolvers<T> {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: any) => void;
-}
-
-//#endregion
-/** Given an array, this is the union of its members' types. */
-//# sourceMappingURL=types.d.ts.map
-
-/** Given an array, this is the union of its members' types. */export { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise };
-//# sourceMappingURL=types.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/vendor/unpromise/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;UAQiB,6BAA6B,QAAQ;EAArC,WAAA,EAAA,GAAA,GAAA,IAAiB;;;AAAY,UAK7B,YAL6B,CAAA,CAAA,CAAA,SAKL,OALK,CAKG,CALH,CAAA,CAAA;EAAO,SAAA,EAAA,GAAA,GAMlC,iBANkC,CAMhB,CANgB,CAAA;oBAQjC,4CAEH,MAAM,WAAW,YAAY,kDAIpB,WAAW,YAAY,sBAG1C,kBAAkB,WAAW;EAZnB,KAAA,EAAA,CAAA,UAAY,KAAA,CAAA,CAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAgBH,OAhBG,GAgBO,WAhBP,CAgBmB,OAhBnB,CAAA,CAAA,GAAA,IAAA,EAAA,GAmBtB,iBAnBsB,CAmBJ,CAnBI,GAmBA,OAnBA,CAAA;EAAA,OAAA,EAAA,CAAA,SAAA,CAAA,EAAA,CAAA,GAAA,GAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAuBtB,iBAvBsB,CAuBJ,CAvBI,CAAA;;AACQ,KAyBzB,eAzByB,CAAA,CAAA,CAAA,GAAA,CAAA,OAAA,EAAA,CAAA,KAAA,EA0BlB,CA1BkB,GA0Bd,WA1Bc,CA0BF,CA1BE,CAAA,EAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA,EAAA,GAAA,IAAA;;;;AAId,UA6BN,oBA7BM,CAAA,CAAA,CAAA,CAAA;EAAQ,OAAe,EA8BnC,OA9BmC,CA8B3B,CA9B2B,CAAA;EAAQ,OAApB,EAAA,CAAA,KAAA,EA+Bf,CA/Be,GA+BX,WA/BW,CA+BC,CA/BD,CAAA,EAAA,GAAA,IAAA;EAAW,MAInB,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA"}

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

@@ -1,34 +0,0 @@
-//#region src/vendor/unpromise/types.d.ts
-/** 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. */
-interface SubscribedPromise<T> extends Promise<T> {
-  unsubscribe: () => void;
-}
-/** Duplicate of Promise interface, except each call returns SubscribedPromise */
-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>;
-}
-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 */
-interface PromiseWithResolvers<T> {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: any) => void;
-}
-
-//#endregion
-/** Given an array, this is the union of its members' types. */
-//# sourceMappingURL=types.d.ts.map
-
-/** Given an array, this is the union of its members' types. */export { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise };
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/vendor/unpromise/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;UAQiB,6BAA6B,QAAQ;EAArC,WAAA,EAAA,GAAA,GAAA,IAAiB;;;AAAY,UAK7B,YAL6B,CAAA,CAAA,CAAA,SAKL,OALK,CAKG,CALH,CAAA,CAAA;EAAO,SAAA,EAAA,GAAA,GAMlC,iBANkC,CAMhB,CANgB,CAAA;oBAQjC,4CAEH,MAAM,WAAW,YAAY,kDAIpB,WAAW,YAAY,sBAG1C,kBAAkB,WAAW;EAZnB,KAAA,EAAA,CAAA,UAAY,KAAA,CAAA,CAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAgBH,OAhBG,GAgBO,WAhBP,CAgBmB,OAhBnB,CAAA,CAAA,GAAA,IAAA,EAAA,GAmBtB,iBAnBsB,CAmBJ,CAnBI,GAmBA,OAnBA,CAAA;EAAA,OAAA,EAAA,CAAA,SAAA,CAAA,EAAA,CAAA,GAAA,GAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAuBtB,iBAvBsB,CAuBJ,CAvBI,CAAA;;AACQ,KAyBzB,eAzByB,CAAA,CAAA,CAAA,GAAA,CAAA,OAAA,EAAA,CAAA,KAAA,EA0BlB,CA1BkB,GA0Bd,WA1Bc,CA0BF,CA1BE,CAAA,EAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA,EAAA,GAAA,IAAA;;;;AAId,UA6BN,oBA7BM,CAAA,CAAA,CAAA,CAAA;EAAQ,OAAe,EA8BnC,OA9BmC,CA8B3B,CA9B2B,CAAA;EAAQ,OAApB,EAAA,CAAA,KAAA,EA+Bf,CA/Be,GA+BX,WA/BW,CA+BC,CA/BD,CAAA,EAAA,GAAA,IAAA;EAAW,MAInB,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA"}

package/dist/vendor/unpromise/unpromise.d.mts

@@ -1,157 +0,0 @@
-import { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise } from "./types.mjs";
-
-//#region src/vendor/unpromise/unpromise.d.ts
-/**
-* 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!
-*
-*/
-/**
- * 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!
- *
- */
-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]>;
-} //#endregion
-
-/** 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 { Unpromise as Unpromise$1 };
-//# sourceMappingURL=unpromise.d.mts.map

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

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

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

@@ -1,157 +0,0 @@
-import { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise } from "./types.js";
-
-//#region src/vendor/unpromise/unpromise.d.ts
-/**
-* 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!
-*
-*/
-/**
- * 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!
- *
- */
-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]>;
-} //#endregion
-
-/** 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 { Unpromise };
-//# sourceMappingURL=unpromise.d.ts.map

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

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