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

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

@@ -1,60 +1,64 @@
+//#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. */
-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'];
+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 +1 @@
-{"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"}
+{"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

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

package/dist/vendor/unpromise/index.mjs

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

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

@@ -0,0 +1,34 @@
+//#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

@@ -0,0 +1 @@
+{"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,3 +1,4 @@
+//#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
@@ -5,24 +6,29 @@
  *
  * Calling unsubscribe() removes the subscription, eliminating
  * all references to the SubscribedPromise. */
-export interface SubscribedPromise<T> extends Promise<T> {
-    unsubscribe: () => void;
+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>;
+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;
+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;
+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 +1 @@
-{"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"}
+{"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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1 @@
+{"version":3,"file":"unpromise.d.mts","names":[],"sources":["../../../src/vendor/unpromise/unpromise.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Da,wBAAwB,aAAa;;EAArC;EAAS,mBAAA,OAAA,EAIQ,OAJR,CAIgB,CAJhB,CAAA,GAIqB,WAJrB,CAIiC,CAJjC,CAAA;EAAA;;EAIiB,UAAT,WAAA,EAIL,aAJK,CAIS,oBAJT,CAI8B,CAJ9B,CAAA,CAAA,GAAA,IAAA;EAAO;;;EAIwB,UAAtB,UAAA,EAKf,oBALe,CAKM,CALN,CAAA,GAAA,IAAA;EAAoB;;;;;;EAcb,UAAb,WAAA,CAAA,OAAA,EADA,OACA,CADQ,CACR,CAAA;EAAW,UACM,WAAA,CAAA,OAAA,EADjB,WACiB,CADL,CACK,CAAA;EAAC,UAAjB,WAAA,CAAA,QAAA,EAAA,eAAA,CAAgB,CAAhB,CAAA;EAAe;;;;;;;;;;;;;;;;;;EAyHf,SAA7B,CAAA,CAAA,EA3DU,iBA2DV,CA3D4B,CA2D5B,CAAA;EAAiB;EAQ2C,IAAnB,CAAA,WA9B5B,CA8B4B,EAAA,WAAA,KAAA,CAAA,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,KAAA,EA5B7B,CA4B6B,EAAA,GA5BvB,QA4BuB,GA5BZ,WA4BY,CA5BA,QA4BA,CAAA,CAAA,GAAA,IAAA,EAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAxBpB,QAwBoB,GAxBT,WAwBS,CAxBG,QAwBH,CAAA,CAAA,GAAA,IAAA,CAAA,EArBzC,iBAqByC,CArBvB,QAqBuB,GArBZ,QAqBY,CAAA;EAAiB,KAUnD,CAAA,UAAO,KAAA,CAAA,CAAA,UAAA,CAAA,EAAA,CAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GArBO,OAqBP,GArBiB,WAqBjB,CArB6B,OAqB7B,CAAA,CAAA,GAAA,IAAA,CAAA,EAlBd,iBAkBc,CAlBI,CAkBJ,GAlBQ,OAkBR,CAAA;EAAW,OAMS,CAAA,SAAA,CAAA,EAAA,CAAA,GAAA,GAAA,IAAA,CAAA,GAAA,IAAA,CAAA,EAhBO,iBAgBP,CAhByB,CAgBzB,CAAA;EAAC;EAAF,UAN1B,MAAA,CAAO,WAAA,IAMsC,WAAA;EAAC;EAAF;;EAQY,OAAG,KAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EAR5C,WAQ4C,CARhC,CAQgC,CAAA,CAAA,EAR3B,YAQ2B,CARd,CAQc,CAAA;EAAA;EAAA,iBAQL,yBAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EART,WAQS,CARG,CAQH,CAAA,CAAA,EARK,SAQL,CARK,CAQL,CAAA;EAAC;EAAF,iBACP,sBAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EADJ,WACI,CADQ,CACR,CAAA,CAAA,EAAb,YAAa,CAAA,CAAA,CAAA,GAAA,SAAA;EAAC;EAAF;;EAOb,OAAb,OAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAAJ,CAAI,GAAA,WAAA,CAAY,CAAZ,CAAA,CAAA,EAQoB,iBARpB,CASzB,OATyB,CASjB,CATiB,CAAA,CAAA;EAAW;;;EAQ0B,OASxD,GAAA,CAAA,UAAA,SAAA,OAAA,EAAA,GAAA,EAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,EACP,OADO,CACC,OADD,CACS,CADT,CAAA,MAAA,CAAA,CAAA,CAAA;EAAC;;;EACD,OAmBA,IAAA,CAAA,UAAA,SAAA,OAAA,EAAA,GAAA,EAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,EACP,OADO,CACC,OADD,CACS,CADT,CAAA,MAAA,CAAA,CAAA,CAAA;EAAC;;;;;;;;AArOoC;;;;yCAiQF,qCACxB,aAAU,kBAAA"}

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

@@ -1,4 +1,39 @@
-import type { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise } from "./types";
+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
@@ -32,90 +67,91 @@ import type { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPro
  * 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]>;
-}
+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 declare function resolveSelfTuple<TPromise extends Promise<unknown>>(promise: TPromise): SubscribedPromise<readonly [TPromise]>;
+export { Unpromise };
 //# sourceMappingURL=unpromise.d.ts.map