@trpc/server 11.1.3-alpha-tmp-tsdown.24 → 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'];
-}
-//# sourceMappingURL=spec.d.ts.map
-//#endregion
-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":";;AASA;;;;AAEsD,UAFrC,gBAEqC,CAAA,QAAA,OAAA,EAAA,SAFM,KAEN,CAAA,CAAA;EAAM;EAAd,SAAA,WAAA,EAAtB,gBAAA,CAAiB,KAAK,CAAC,KAAD,EAAQ,MAAR,CAAA;AAG9C;AAAyC,kBAAhB,gBAAA,CAAgB;EAAA;EAEe,UAQxC,KAAA,CAAA,QAAA,OAAA,EAAA,SARmC,KAQnC,CAAA,CAAA;IAAP;IAAgC,SAAA,OAAA,EAAA,CAAA;IAAP;IAAR,SAAA,MAAA,EAAA,MAAA;IAEC;IAAO,SAAA,QAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAFzB,MAEyB,CAFlB,MAEkB,CAAA,GAFR,OAEQ,CAFA,MAEA,CAFO,MAEP,CAAA,CAAA;IAAb;IAIwB,SAAA,KAAA,CAAA,EAJxB,KAIwB,CAJlB,KAIkB,EAJX,MAIW,CAAA,GAAA,SAAA;EAAM;EAAP;EAAwB,KAKhD,MAAA,CAAA,MAAA,CAAA,GALW,aAKX,CALyB,MAKzB,CAAA,GALmC,aAKnC;EAAM;EAQc,UAAnB,aAAA,CAAA,MAAA,CAAA,CAAA;IAQa;IAAc,SAAA,KAAA,EAhB5B,MAgB4B;IAA5B;IAMF,SAAA,MAAA,CAAA,EAAA,SAAA;EAAW;EAI2B;EAE/B,UAEJ,aAAA,CAAA;IAImB;IACpC,SAAA,MAAA,EA3BiB,aA2BjB,CA3B+B,KA2B/B,CAAA;EAAM;EAD6D;EAKd,UACrD,KAAA,CAAA;IADyD;IAAW,SAAA,OAAA,EAAA,MAAA;;oBAvBpD,cAAc,cAAc;;;;;kBAM9B;;;4CAIiC;;oBAE/B;;qBAEC;;;iCAImB,oBAAoB,YACxD;;kCAIqC,oBAAoB,YACzD"}

package/dist/vendor/unpromise/index.js

@@ -1 +0,0 @@
-const require_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,33 +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;
-}
-/** Given an array, this is the union of its members' types. */
-//# sourceMappingURL=types.d.ts.map
-
-//#endregion
-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":";;AAQA;;;;AAAqD;AAKrD;AAA6B,UALZ,iBAKY,CAAA,CAAA,CAAA,SALiB,OAKjB,CALyB,CAKzB,CAAA,CAAA;EAAA,WAAoB,EAAA,GAAA,GAAA,IAAA;;;AAG7B,UAHH,YAGG,CAAA,CAAA,CAAA,SAHqB,OAGrB,CAH6B,CAG7B,CAAA,CAAA;EAAC,SAEJ,EAAA,GAAA,GAJE,iBAIF,CAJoB,CAIpB,CAAA;EAAC,IAAK,EAAA,CAAA,WAFH,CAEG,EAAA,WAAA,KAAA,CAAA,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,KAAA,EAAN,CAAM,EAAA,GAAA,QAAA,GAAW,WAAX,CAAuB,QAAvB,CAAA,CAAA,GAAA,IAAA,EAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAIG,QAJH,GAIc,WAJd,CAI0B,QAJ1B,CAAA,CAAA,GAAA,IAAA,EAAA,GAOhB,iBAPgB,CAOE,QAPF,GAOa,QAPb,CAAA;EAAQ,KAAe,EAAA,CAAA,UAAA,KAAA,CAAA,CAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAWpB,OAXoB,GAWV,WAXU,CAWE,OAXF,CAAA,CAAA,GAAA,IAAA,EAAA,GAcvC,iBAduC,CAcrB,CAdqB,GAcjB,OAdiB,CAAA;EAAQ,OAApB,EAAA,CAAA,SAAA,CAAA,EAAA,CAAA,GAAA,GAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAkB3B,iBAlB2B,CAkBT,CAlBS,CAAA;;AAIe,KAiBrC,eAjBqC,CAAA,CAAA,CAAA,GAAA,CAAA,OAAA,EAAA,CAAA,KAAA,EAkB9B,CAlB8B,GAkB1B,WAlB0B,CAkBd,CAlBc,CAAA,EAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA,EAAA,GAAA,IAAA;;;;AAG1C,UAsBU,oBAtBV,CAAA,CAAA,CAAA,CAAA;EAAiB,OAIE,EAmBf,OAnBe,CAmBP,CAnBO,CAAA;EAAO,OAAe,EAAA,CAAA,KAAA,EAoB7B,CApB6B,GAoBzB,WApByB,CAoBb,CApBa,CAAA,EAAA,GAAA,IAAA;EAAO,MAAnB,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA"}

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

@@ -1,33 +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;
-}
-/** Given an array, this is the union of its members' types. */
-//# sourceMappingURL=types.d.ts.map
-
-//#endregion
-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":";;AAQA;;;;AAAqD;AAKrD;AAA6B,UALZ,iBAKY,CAAA,CAAA,CAAA,SALiB,OAKjB,CALyB,CAKzB,CAAA,CAAA;EAAA,WAAoB,EAAA,GAAA,GAAA,IAAA;;;AAG7B,UAHH,YAGG,CAAA,CAAA,CAAA,SAHqB,OAGrB,CAH6B,CAG7B,CAAA,CAAA;EAAC,SAEJ,EAAA,GAAA,GAJE,iBAIF,CAJoB,CAIpB,CAAA;EAAC,IAAK,EAAA,CAAA,WAFH,CAEG,EAAA,WAAA,KAAA,CAAA,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,KAAA,EAAN,CAAM,EAAA,GAAA,QAAA,GAAW,WAAX,CAAuB,QAAvB,CAAA,CAAA,GAAA,IAAA,EAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAIG,QAJH,GAIc,WAJd,CAI0B,QAJ1B,CAAA,CAAA,GAAA,IAAA,EAAA,GAOhB,iBAPgB,CAOE,QAPF,GAOa,QAPb,CAAA;EAAQ,KAAe,EAAA,CAAA,UAAA,KAAA,CAAA,CAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAWpB,OAXoB,GAWV,WAXU,CAWE,OAXF,CAAA,CAAA,GAAA,IAAA,EAAA,GAcvC,iBAduC,CAcrB,CAdqB,GAcjB,OAdiB,CAAA;EAAQ,OAApB,EAAA,CAAA,SAAA,CAAA,EAAA,CAAA,GAAA,GAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAkB3B,iBAlB2B,CAkBT,CAlBS,CAAA;;AAIe,KAiBrC,eAjBqC,CAAA,CAAA,CAAA,GAAA,CAAA,OAAA,EAAA,CAAA,KAAA,EAkB9B,CAlB8B,GAkB1B,WAlB0B,CAkBd,CAlBc,CAAA,EAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA,EAAA,GAAA,IAAA;;;;AAG1C,UAsBU,oBAtBV,CAAA,CAAA,CAAA,CAAA;EAAiB,OAIE,EAmBf,OAnBe,CAmBP,CAnBO,CAAA;EAAO,OAAe,EAAA,CAAA,KAAA,EAoB7B,CApB6B,GAoBzB,WApByB,CAoBb,CApBa,CAAA,EAAA,GAAA,IAAA;EAAO,MAAnB,EAAA,CAAA,MAAA,CAAA,EAAA,GAAA,EAAA,GAAA,IAAA"}

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

@@ -1,125 +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!
- *
- */
-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.
- * */
-//#endregion
-export { Unpromise };
-//# 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":";;;;;;AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6I0B,cA7Ib,SA6Ia,CAAA,CAAA,CAAA,YA7IW,YA6IX,CA7IwB,CA6IxB,CAAA,CAAA;EAAO;EAAsB;EAAR,mBAGxB,OAAA,EA5IO,OA4IP,CA5Ie,CA4If,CAAA,GA5IoB,WA4IpB,CA5IgC,CA4IhC,CAAA;EAAC;;EAAF,UAQ0C,WAAA,EAhJvC,aAgJuC,CAhJzB,oBAgJyB,CAhJJ,CAgJI,CAAA,CAAA,GAAA,IAAA;EAAC;;;EAgBzB,UAAb,UAAA,EA3JH,oBA2JG,CA3JkB,CA2JlB,CAAA,GAAA,IAAA;EAAW;;;;;;EAQiC,UAQL,WAAA,CAAA,OAAA,EAnKjC,OAmKiC,CAnKzB,CAmKyB,CAAA;EAAC,UAAb,WAAA,CAAA,OAAA,EAlKrB,WAkKqB,CAlKT,CAkKS,CAAA;EAAW,UACP,WAAA,CAAA,QAAA,EAlKxB,eAkKwB,CAlKR,CAkKQ,CAAA;EAAC;;;;;;;;;;;;;;;;;;EAyE1B,SAAA,CAAA,CAAA,EA7KlB,iBA6KkB,CA7KA,CA6KA,CAAA;EAAA;EAlQgB,IAAA,CAAA,WA0H/B,CA1H+B,EAAA,WAAA,KAAA,CAAA,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,KAAA,EA4HhC,CA5HgC,EAAA,GA4H1B,QA5H0B,GA4Hf,WA5He,CA4HH,QA5HG,CAAA,CAAA,GAAA,IAAA,EAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAgIvB,QAhIuB,GAgIZ,WAhIY,CAgIA,QAhIA,CAAA,CAAA,GAAA,IAAA,CAAA,EAmI5C,iBAnI4C,CAmI1B,QAnI0B,GAmIf,QAnIe,CAAA;wDA6IvB,UAAU,YAAY,mBAG3C,kBAAkB,IAAI;4CAQmB,kBAAkB;;YAUpD,MAAA,CAAO,WAAA;;;;2BAMQ,YAAY,KAAK,aAAa;;yDAQA,YAAY,KAAE,UAAA;;sDAQjB,YAAY,KACrB,aAAa;;;;2BAO/B,IAAI,YAAY,KAQQ,kBAC7C,QAAQ;;;;wDAQF,IACP,QAAQ,QAAQ;;;;yDAmBT,IACP,QAAQ,QAAQ;;;;;;;;;;;;;yCA2B0B,qCACxB,aAAU,kBAAA"}

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

@@ -1,125 +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!
- *
- */
-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.
- * */
-//#endregion
-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":";;;;;;AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6I0B,cA7Ib,SA6Ia,CAAA,CAAA,CAAA,YA7IW,YA6IX,CA7IwB,CA6IxB,CAAA,CAAA;EAAO;EAAsB;EAAR,mBAGxB,OAAA,EA5IO,OA4IP,CA5Ie,CA4If,CAAA,GA5IoB,WA4IpB,CA5IgC,CA4IhC,CAAA;EAAC;;EAAF,UAQ0C,WAAA,EAhJvC,aAgJuC,CAhJzB,oBAgJyB,CAhJJ,CAgJI,CAAA,CAAA,GAAA,IAAA;EAAC;;;EAgBzB,UAAb,UAAA,EA3JH,oBA2JG,CA3JkB,CA2JlB,CAAA,GAAA,IAAA;EAAW;;;;;;EAQiC,UAQL,WAAA,CAAA,OAAA,EAnKjC,OAmKiC,CAnKzB,CAmKyB,CAAA;EAAC,UAAb,WAAA,CAAA,OAAA,EAlKrB,WAkKqB,CAlKT,CAkKS,CAAA;EAAW,UACP,WAAA,CAAA,QAAA,EAlKxB,eAkKwB,CAlKR,CAkKQ,CAAA;EAAC;;;;;;;;;;;;;;;;;;EAyE1B,SAAA,CAAA,CAAA,EA7KlB,iBA6KkB,CA7KA,CA6KA,CAAA;EAAA;EAlQgB,IAAA,CAAA,WA0H/B,CA1H+B,EAAA,WAAA,KAAA,CAAA,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,KAAA,EA4HhC,CA5HgC,EAAA,GA4H1B,QA5H0B,GA4Hf,WA5He,CA4HH,QA5HG,CAAA,CAAA,GAAA,IAAA,EAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAgIvB,QAhIuB,GAgIZ,WAhIY,CAgIA,QAhIA,CAAA,CAAA,GAAA,IAAA,CAAA,EAmI5C,iBAnI4C,CAmI1B,QAnI0B,GAmIf,QAnIe,CAAA;wDA6IvB,UAAU,YAAY,mBAG3C,kBAAkB,IAAI;4CAQmB,kBAAkB;;YAUpD,MAAA,CAAO,WAAA;;;;2BAMQ,YAAY,KAAK,aAAa;;yDAQA,YAAY,KAAE,UAAA;;sDAQjB,YAAY,KACrB,aAAa;;;;2BAO/B,IAAI,YAAY,KAQQ,kBAC7C,QAAQ;;;;wDAQF,IACP,QAAQ,QAAQ;;;;yDAmBT,IACP,QAAQ,QAAQ;;;;;;;;;;;;;yCA2B0B,qCACxB,aAAU,kBAAA"}

package/dist/vendor/unpromise/unpromise.js

@@ -1,243 +0,0 @@
-
-//#region src/vendor/unpromise/unpromise.ts
-/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
-* which is retained for the lifetime of the original Promise.
-*/
-const subscribableCache = /* @__PURE__ */ new WeakMap();
-/** A NOOP function allowing a consistent interface for settled
-* SubscribedPromises (settled promises are not subscribed - they resolve
-* immediately). */
-const NOOP = () => {};
-/**
-* 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!
-*
-*/
-var Unpromise = class Unpromise {
-	/** INSTANCE IMPLEMENTATION */
-	/** The promise shadowed by this Unpromise<T>  */
-	promise;
-	/** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-	* after the original promise settles - no further notifications will be issued. */
-	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. */
-	settlement = null;
-	constructor(arg) {
-		if (typeof arg === "function") this.promise = new Promise(arg);
-		else this.promise = arg;
-		const thenReturn = this.promise.then((value) => {
-			const { subscribers } = this;
-			this.subscribers = null;
-			this.settlement = {
-				status: "fulfilled",
-				value
-			};
-			subscribers?.forEach(({ resolve }) => {
-				resolve(value);
-			});
-		});
-		if ("catch" in thenReturn) thenReturn.catch((reason) => {
-			const { subscribers } = this;
-			this.subscribers = null;
-			this.settlement = {
-				status: "rejected",
-				reason
-			};
-			subscribers?.forEach(({ reject }) => {
-				reject(reason);
-			});
-		});
-	}
-	/** 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() {
-		let promise;
-		let unsubscribe;
-		const { settlement } = this;
-		if (settlement === null) {
-			if (this.subscribers === null) 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 {
-			const { status } = settlement;
-			if (status === "fulfilled") promise = Promise.resolve(settlement.value);
-			else promise = Promise.reject(settlement.reason);
-			unsubscribe = NOOP;
-		}
-		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 });
-	}
-	/** TOSTRING SUPPORT */
-	[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(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);
-		subscribableCache.set(created, created);
-		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) {
-		const selfPromises = promises.map(resolveSelfTuple);
-		try {
-			return await Promise.race(selfPromises);
-		} finally {
-			for (const promise of selfPromises) promise.unsubscribe();
-		}
-	}
-};
-/** 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;
-}
-
-//#endregion
-exports.Unpromise = Unpromise;