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

package/dist/vendor/unpromise/unpromise.mjs

@@ -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
-export { Unpromise };
-//# sourceMappingURL=unpromise.mjs.map

package/dist/vendor/unpromise/unpromise.mjs.map

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