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

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs

@@ -1,165 +1,70 @@
-import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { throwAbortError } from '../../http/abortError.mjs';
-import { makeAsyncResource } from './disposable.mjs';
-import { timerResource, disposablePromiseTimerResult } from './timerResource.mjs';
+import { __toESM } from "../../../_virtual/rolldown_runtime.mjs";
+import { throwAbortError } from "../../http/abortError.mjs";
+import { Unpromise } from "../../../vendor/unpromise/unpromise.mjs";
+import { makeAsyncResource } from "./disposable.mjs";
+import { disposablePromiseTimerResult, timerResource } from "./timerResource.mjs";
+import { require_usingCtx } from "../../../node_modules/.pnpm/@oxc-project_runtime@0.71.0/node_modules/@oxc-project/runtime/src/helpers/usingCtx.mjs";
 
-function _ts_add_disposable_resource(env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() {
-            try {
-                inner.call(this);
-            } catch (e) {
-                return Promise.reject(e);
-            }
-        };
-        env.stack.push({
-            value: value,
-            dispose: dispose,
-            async: async
-        });
-    } else if (async) {
-        env.stack.push({
-            async: true
-        });
-    }
-    return value;
-}
-function _ts_dispose_resources(env) {
-    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
-        function fail(e) {
-            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while(r = env.stack.pop()){
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-                            fail(e);
-                            return next();
-                        });
-                    } else s |= 1;
-                } catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    })(env);
-}
+//#region src/unstable-core-do-not-import/stream/utils/asyncIterable.ts
+var import_usingCtx = __toESM(require_usingCtx());
 function iteratorResource(iterable) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    return makeAsyncResource(iterator, async ()=>{
-        await iterator.return?.();
-    });
+	const iterator = iterable[Symbol.asyncIterator]();
+	if (iterator[Symbol.asyncDispose]) return iterator;
+	return makeAsyncResource(iterator, async () => {
+		await iterator.return?.();
+	});
 }
 /**
- * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically aborts after the specified duration.
- */ async function* withMaxDuration(iterable, opts) {
-    const env = {
-        stack: [],
-        error: void 0,
-        hasError: false
-    };
-    try {
-        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
-        ;
-        const timer = _ts_add_disposable_resource(env, timerResource(opts.maxDurationMs), false);
-        ;
-        const timerPromise = timer.start();
-        // declaration outside the loop for garbage collection reasons
-        let result;
-        while(true){
-            result = await Unpromise.race([
-                iterator.next(),
-                timerPromise
-            ]);
-            if (result === disposablePromiseTimerResult) {
-                // cancelled due to timeout
-                throwAbortError();
-            }
-            if (result.done) {
-                return result;
-            }
-            yield result.value;
-            // free up reference for garbage collection
-            result = null;
-        }
-    } catch (e) {
-        env.error = e;
-        env.hasError = true;
-    } finally{
-        const result = _ts_dispose_resources(env);
-        if (result) await result;
-    }
+* Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically aborts after the specified duration.
+*/
+async function* withMaxDuration(iterable, opts) {
+	try {
+		var _usingCtx = (0, import_usingCtx.default)();
+		const iterator = _usingCtx.a(iteratorResource(iterable));
+		const timer = _usingCtx.u(timerResource(opts.maxDurationMs));
+		const timerPromise = timer.start();
+		let result;
+		while (true) {
+			result = await Unpromise.race([iterator.next(), timerPromise]);
+			if (result === disposablePromiseTimerResult) throwAbortError();
+			if (result.done) return result;
+			yield result.value;
+			result = null;
+		}
+	} catch (_) {
+		_usingCtx.e = _;
+	} finally {
+		await _usingCtx.d();
+	}
 }
 /**
- * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
- * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
- * values may still come through. After this period, the generator aborts.
- */ async function* takeWithGrace(iterable, opts) {
-    const env = {
-        stack: [],
-        error: void 0,
-        hasError: false
-    };
-    try {
-        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
-        ;
-        // declaration outside the loop for garbage collection reasons
-        let result;
-        const timer = _ts_add_disposable_resource(env, timerResource(opts.gracePeriodMs), false);
-        ;
-        let count = opts.count;
-        let timerPromise = new Promise(()=>{
-        // never resolves
-        });
-        while(true){
-            result = await Unpromise.race([
-                iterator.next(),
-                timerPromise
-            ]);
-            if (result === disposablePromiseTimerResult) {
-                throwAbortError();
-            }
-            if (result.done) {
-                return result.value;
-            }
-            yield result.value;
-            if (--count === 0) {
-                timerPromise = timer.start();
-            }
-            // free up reference for garbage collection
-            result = null;
-        }
-    } catch (e) {
-        env.error = e;
-        env.hasError = true;
-    } finally{
-        const result = _ts_dispose_resources(env);
-        if (result) await result;
-    }
+* Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+* {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+* values may still come through. After this period, the generator aborts.
+*/
+async function* takeWithGrace(iterable, opts) {
+	try {
+		var _usingCtx3 = (0, import_usingCtx.default)();
+		const iterator = _usingCtx3.a(iteratorResource(iterable));
+		let result;
+		const timer = _usingCtx3.u(timerResource(opts.gracePeriodMs));
+		let count = opts.count;
+		let timerPromise = new Promise(() => {});
+		while (true) {
+			result = await Unpromise.race([iterator.next(), timerPromise]);
+			if (result === disposablePromiseTimerResult) throwAbortError();
+			if (result.done) return result.value;
+			yield result.value;
+			if (--count === 0) timerPromise = timer.start();
+			result = null;
+		}
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		await _usingCtx3.d();
+	}
 }
 
+//#endregion
 export { iteratorResource, takeWithGrace, withMaxDuration };
+//# sourceMappingURL=asyncIterable.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterable.mjs","names":["iterable: AsyncIterable<TYield, TReturn, TNext>","iterable: AsyncIterable<T>","opts: { maxDurationMs: number }","result: null | IteratorResult<T> | typeof disposablePromiseTimerResult","opts: {\n    count: number;\n    gracePeriodMs: number;\n  }"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"sourcesContent":["import { Unpromise } from '../../../vendor/unpromise';\nimport { throwAbortError } from '../../http/abortError';\nimport { makeAsyncResource } from './disposable';\nimport { disposablePromiseTimerResult, timerResource } from './timerResource';\n\nexport function iteratorResource<TYield, TReturn, TNext>(\n  iterable: AsyncIterable<TYield, TReturn, TNext>,\n): AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable {\n  const iterator = iterable[Symbol.asyncIterator]();\n\n  // @ts-expect-error - this is added in node 24 which we don't officially support yet\n  // eslint-disable-next-line no-restricted-syntax\n  if (iterator[Symbol.asyncDispose]) {\n    return iterator as AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable;\n  }\n\n  return makeAsyncResource(iterator, async () => {\n    await iterator.return?.();\n  });\n}\n/**\n * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically aborts after the specified duration.\n */\nexport async function* withMaxDuration<T>(\n  iterable: AsyncIterable<T>,\n  opts: { maxDurationMs: number },\n): AsyncGenerator<T> {\n  await using iterator = iteratorResource(iterable);\n\n  using timer = timerResource(opts.maxDurationMs);\n\n  const timerPromise = timer.start();\n\n  // declaration outside the loop for garbage collection reasons\n  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;\n\n  while (true) {\n    result = await Unpromise.race([iterator.next(), timerPromise]);\n    if (result === disposablePromiseTimerResult) {\n      // cancelled due to timeout\n      throwAbortError();\n    }\n    if (result.done) {\n      return result;\n    }\n    yield result.value;\n    // free up reference for garbage collection\n    result = null;\n  }\n}\n\n/**\n * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first\n * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further\n * values may still come through. After this period, the generator aborts.\n */\nexport async function* takeWithGrace<T>(\n  iterable: AsyncIterable<T>,\n  opts: {\n    count: number;\n    gracePeriodMs: number;\n  },\n): AsyncGenerator<T> {\n  await using iterator = iteratorResource(iterable);\n\n  // declaration outside the loop for garbage collection reasons\n  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;\n\n  using timer = timerResource(opts.gracePeriodMs);\n\n  let count = opts.count;\n\n  let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {\n    // never resolves\n  });\n\n  while (true) {\n    result = await Unpromise.race([iterator.next(), timerPromise]);\n    if (result === disposablePromiseTimerResult) {\n      throwAbortError();\n    }\n    if (result.done) {\n      return result.value;\n    }\n    yield result.value;\n    if (--count === 0) {\n      timerPromise = timer.start();\n    }\n    // free up reference for garbage collection\n    result = null;\n  }\n}\n"],"mappings":";;;;;;;;;AAKA,SAAgB,iBACdA,UACyD;CACzD,MAAM,WAAW,SAAS,OAAO,gBAAgB;AAIjD,KAAI,SAAS,OAAO,cAClB,QAAO;AAGT,QAAO,kBAAkB,UAAU,YAAY;AAC7C,QAAM,SAAS,UAAU;CAC1B,EAAC;AACH;;;;AAID,gBAAuB,gBACrBC,UACAC,MACmB;;;EACnB,MAAY,uBAAW,iBAAiB,SAAS;EAEjD,MAAM,oBAAQ,cAAc,KAAK,cAAc;EAE/C,MAAM,eAAe,MAAM,OAAO;EAGlC,IAAIC;AAEJ,SAAO,MAAM;AACX,YAAS,MAAM,UAAU,KAAK,CAAC,SAAS,MAAM,EAAE,YAAa,EAAC;AAC9D,OAAI,WAAW,6BAEb,kBAAiB;AAEnB,OAAI,OAAO,KACT,QAAO;AAET,SAAM,OAAO;AAEb,YAAS;EACV;;;;;;AACF;;;;;;AAOD,gBAAuB,cACrBF,UACAG,MAImB;;;EACnB,MAAY,wBAAW,iBAAiB,SAAS;EAGjD,IAAID;EAEJ,MAAM,qBAAQ,cAAc,KAAK,cAAc;EAE/C,IAAI,QAAQ,KAAK;EAEjB,IAAI,eAAe,IAAI,QAA6C,MAAM,CAEzE;AAED,SAAO,MAAM;AACX,YAAS,MAAM,UAAU,KAAK,CAAC,SAAS,MAAM,EAAE,YAAa,EAAC;AAC9D,OAAI,WAAW,6BACb,kBAAiB;AAEnB,OAAI,OAAO,KACT,QAAO,OAAO;AAEhB,SAAM,OAAO;AACb,OAAI,EAAE,UAAU,EACd,gBAAe,MAAM,OAAO;AAG9B,YAAS;EACV;;;;;;AACF"}

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.mts

@@ -0,0 +1,13 @@
+//#region src/unstable-core-do-not-import/stream/utils/createDeferred.d.ts
+declare function createDeferred<TValue = void>(): {
+  promise: Promise<TValue>;
+  resolve: (value: TValue) => void;
+  reject: (error: unknown) => void;
+};
+type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
+
+//#endregion
+//# sourceMappingURL=createDeferred.d.ts.map
+
+export { Deferred, createDeferred as createDeferred$1 };
+//# sourceMappingURL=createDeferred.d.mts.map

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDeferred.d.mts","names":[],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"sourcesContent":[],"mappings":";iBACgB;EAAA,OAAA,SAAA,CAAc,MAAA,CAAA;EAAA,OAAA,EAAA,CAAA,KAAA,EACP,MADO,EAAA,GAAA,IAAA;EAAA,MAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;;AACP,KASX,QATW,CAAA,MAAA,CAAA,GASQ,UATR,CAAA,OAS0B,cAT1B,CASyC,MATzC,CAAA,CAAA;;;AAAM"}

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.ts

@@ -1,7 +1,13 @@
-export declare function createDeferred<TValue = void>(): {
-    promise: Promise<TValue>;
-    resolve: (value: TValue) => void;
-    reject: (error: unknown) => void;
+//#region src/unstable-core-do-not-import/stream/utils/createDeferred.d.ts
+declare function createDeferred<TValue = void>(): {
+  promise: Promise<TValue>;
+  resolve: (value: TValue) => void;
+  reject: (error: unknown) => void;
 };
-export type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
+type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
+
+//#endregion
+//# sourceMappingURL=createDeferred.d.ts.map
+
+export { Deferred, createDeferred };
 //# sourceMappingURL=createDeferred.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createDeferred.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"names":[],"mappings":"AACA,wBAAgB,cAAc,CAAC,MAAM,GAAG,IAAI;;qBACrB,MAAM,KAAK,IAAI;oBAChB,OAAO,KAAK,IAAI;EAOrC;AACD,MAAM,MAAM,QAAQ,CAAC,MAAM,IAAI,UAAU,CAAC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC"}
+{"version":3,"file":"createDeferred.d.ts","names":[],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"sourcesContent":[],"mappings":";iBACgB;EAAA,OAAA,SAAA,CAAc,MAAA,CAAA;EAAA,OAAA,EAAA,CAAA,KAAA,EACP,MADO,EAAA,GAAA,IAAA;EAAA,MAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;;AACP,KASX,QATW,CAAA,MAAA,CAAA,GASQ,UATR,CAAA,OAS0B,cAT1B,CASyC,MATzC,CAAA,CAAA;;;AAAM"}

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.js

@@ -1,17 +1,18 @@
-'use strict';
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
+//#region src/unstable-core-do-not-import/stream/utils/createDeferred.ts
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		promise,
+		resolve,
+		reject
+	};
 }
 
-exports.createDeferred = createDeferred;
+//#endregion
+exports.createDeferred = createDeferred;

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.mjs

@@ -1,15 +1,18 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
+//#region src/unstable-core-do-not-import/stream/utils/createDeferred.ts
+function createDeferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		promise,
+		resolve,
+		reject
+	};
 }
 
+//#endregion
 export { createDeferred };
+//# sourceMappingURL=createDeferred.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/createDeferred.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDeferred.mjs","names":["resolve: (value: TValue) => void","reject: (error: unknown) => void"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/createDeferred.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\nexport function createDeferred<TValue = void>() {\n  let resolve: (value: TValue) => void;\n  let reject: (error: unknown) => void;\n  const promise = new Promise<TValue>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, resolve: resolve!, reject: reject! };\n}\nexport type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;\n"],"mappings":";AACA,SAAgB,iBAAgC;CAC9C,IAAIA;CACJ,IAAIC;CACJ,MAAM,UAAU,IAAI,QAAgB,CAAC,KAAK,QAAQ;AAChD,YAAU;AACV,WAAS;CACV;AAED,QAAO;EAAE;EAAkB;EAAkB;CAAS;AACvD"}

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.mts

@@ -0,0 +1,23 @@
+//#region src/unstable-core-do-not-import/stream/utils/disposable.d.ts
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */
+declare function makeResource<T>(thing: T, dispose: () => void): T & Disposable;
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */
+declare function makeAsyncResource<T>(thing: T, dispose: () => Promise<void>): T & AsyncDisposable;
+
+//#endregion
+//# sourceMappingURL=disposable.d.ts.map
+
+export { makeAsyncResource as makeAsyncResource$1, makeResource as makeResource$1 };
+//# sourceMappingURL=disposable.d.mts.map

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.mts","names":[],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"sourcesContent":[],"mappings":";;;;;;;;iBAegB,uBAAuB,yBAAyB,IAAI;AAApE;;;;;AAA8E;;iBAsB9D,4BACP,kBACQ,gBACd,IAAI"}

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts

@@ -1,3 +1,4 @@
+//#region src/unstable-core-do-not-import/stream/utils/disposable.d.ts
 /**
  * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
  * The returned object is the original value augmented with a Symbol.dispose method.
@@ -5,7 +6,7 @@
  * @param dispose Function to call when disposing the resource
  * @returns The original value with Symbol.dispose method added
  */
-export declare function makeResource<T>(thing: T, dispose: () => void): T & Disposable;
+declare function makeResource<T>(thing: T, dispose: () => void): T & Disposable;
 /**
  * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
  * The returned object is the original value augmented with a Symbol.asyncDispose method.
@@ -13,5 +14,10 @@ export declare function makeResource<T>(thing: T, dispose: () => void): T & Disp
  * @param dispose Async function to call when disposing the resource
  * @returns The original value with Symbol.asyncDispose method added
  */
-export declare function makeAsyncResource<T>(thing: T, dispose: () => Promise<void>): T & AsyncDisposable;
+declare function makeAsyncResource<T>(thing: T, dispose: () => Promise<void>): T & AsyncDisposable;
+
+//#endregion
+//# sourceMappingURL=disposable.d.ts.map
+
+export { makeAsyncResource, makeResource };
 //# sourceMappingURL=disposable.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,CAAC,GAAG,UAAU,CAa7E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,CAAC,GAAG,eAAe,CAarB"}
+{"version":3,"file":"disposable.d.ts","names":[],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"sourcesContent":[],"mappings":";;;;;;;;iBAegB,uBAAuB,yBAAyB,IAAI;AAApE;;;;;AAA8E;;iBAsB9D,4BACP,kBACQ,gBACd,IAAI"}

package/dist/unstable-core-do-not-import/stream/utils/disposable.js

@@ -1,46 +1,40 @@
-'use strict';
 
-// @ts-expect-error - polyfilling symbol
-// eslint-disable-next-line no-restricted-syntax
-var _Symbol, // @ts-expect-error - polyfilling symbol
-// eslint-disable-next-line no-restricted-syntax
-_Symbol1;
-(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
-(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+//#region src/unstable-core-do-not-import/stream/utils/disposable.ts
+Symbol.dispose ??= Symbol();
+Symbol.asyncDispose ??= Symbol();
 /**
- * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
- * The returned object is the original value augmented with a Symbol.dispose method.
- * @param thing The value to make disposable
- * @param dispose Function to call when disposing the resource
- * @returns The original value with Symbol.dispose method added
- */ function makeResource(thing, dispose) {
-    const it = thing;
-    // eslint-disable-next-line no-restricted-syntax
-    const existing = it[Symbol.dispose];
-    // eslint-disable-next-line no-restricted-syntax
-    it[Symbol.dispose] = ()=>{
-        dispose();
-        existing?.();
-    };
-    return it;
+* Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+* The returned object is the original value augmented with a Symbol.dispose method.
+* @param thing The value to make disposable
+* @param dispose Function to call when disposing the resource
+* @returns The original value with Symbol.dispose method added
+*/
+function makeResource(thing, dispose) {
+	const it = thing;
+	const existing = it[Symbol.dispose];
+	it[Symbol.dispose] = () => {
+		dispose();
+		existing?.();
+	};
+	return it;
 }
 /**
- * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
- * The returned object is the original value augmented with a Symbol.asyncDispose method.
- * @param thing The value to make async disposable
- * @param dispose Async function to call when disposing the resource
- * @returns The original value with Symbol.asyncDispose method added
- */ function makeAsyncResource(thing, dispose) {
-    const it = thing;
-    // eslint-disable-next-line no-restricted-syntax
-    const existing = it[Symbol.asyncDispose];
-    // eslint-disable-next-line no-restricted-syntax
-    it[Symbol.asyncDispose] = async ()=>{
-        await dispose();
-        await existing?.();
-    };
-    return it;
+* Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+* The returned object is the original value augmented with a Symbol.asyncDispose method.
+* @param thing The value to make async disposable
+* @param dispose Async function to call when disposing the resource
+* @returns The original value with Symbol.asyncDispose method added
+*/
+function makeAsyncResource(thing, dispose) {
+	const it = thing;
+	const existing = it[Symbol.asyncDispose];
+	it[Symbol.asyncDispose] = async () => {
+		await dispose();
+		await existing?.();
+	};
+	return it;
 }
 
+//#endregion
 exports.makeAsyncResource = makeAsyncResource;
-exports.makeResource = makeResource;
+exports.makeResource = makeResource;

package/dist/unstable-core-do-not-import/stream/utils/disposable.mjs

@@ -1,43 +1,39 @@
-// @ts-expect-error - polyfilling symbol
-// eslint-disable-next-line no-restricted-syntax
-var _Symbol, // @ts-expect-error - polyfilling symbol
-// eslint-disable-next-line no-restricted-syntax
-_Symbol1;
-(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
-(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+//#region src/unstable-core-do-not-import/stream/utils/disposable.ts
+Symbol.dispose ??= Symbol();
+Symbol.asyncDispose ??= Symbol();
 /**
- * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
- * The returned object is the original value augmented with a Symbol.dispose method.
- * @param thing The value to make disposable
- * @param dispose Function to call when disposing the resource
- * @returns The original value with Symbol.dispose method added
- */ function makeResource(thing, dispose) {
-    const it = thing;
-    // eslint-disable-next-line no-restricted-syntax
-    const existing = it[Symbol.dispose];
-    // eslint-disable-next-line no-restricted-syntax
-    it[Symbol.dispose] = ()=>{
-        dispose();
-        existing?.();
-    };
-    return it;
+* Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+* The returned object is the original value augmented with a Symbol.dispose method.
+* @param thing The value to make disposable
+* @param dispose Function to call when disposing the resource
+* @returns The original value with Symbol.dispose method added
+*/
+function makeResource(thing, dispose) {
+	const it = thing;
+	const existing = it[Symbol.dispose];
+	it[Symbol.dispose] = () => {
+		dispose();
+		existing?.();
+	};
+	return it;
 }
 /**
- * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
- * The returned object is the original value augmented with a Symbol.asyncDispose method.
- * @param thing The value to make async disposable
- * @param dispose Async function to call when disposing the resource
- * @returns The original value with Symbol.asyncDispose method added
- */ function makeAsyncResource(thing, dispose) {
-    const it = thing;
-    // eslint-disable-next-line no-restricted-syntax
-    const existing = it[Symbol.asyncDispose];
-    // eslint-disable-next-line no-restricted-syntax
-    it[Symbol.asyncDispose] = async ()=>{
-        await dispose();
-        await existing?.();
-    };
-    return it;
+* Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+* The returned object is the original value augmented with a Symbol.asyncDispose method.
+* @param thing The value to make async disposable
+* @param dispose Async function to call when disposing the resource
+* @returns The original value with Symbol.asyncDispose method added
+*/
+function makeAsyncResource(thing, dispose) {
+	const it = thing;
+	const existing = it[Symbol.asyncDispose];
+	it[Symbol.asyncDispose] = async () => {
+		await dispose();
+		await existing?.();
+	};
+	return it;
 }
 
+//#endregion
 export { makeAsyncResource, makeResource };
+//# sourceMappingURL=disposable.mjs.map

package/dist/unstable-core-do-not-import/stream/utils/disposable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.mjs","names":["thing: T","dispose: () => void","dispose: () => Promise<void>"],"sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"sourcesContent":["// @ts-expect-error - polyfilling symbol\n// eslint-disable-next-line no-restricted-syntax\nSymbol.dispose ??= Symbol();\n\n// @ts-expect-error - polyfilling symbol\n// eslint-disable-next-line no-restricted-syntax\nSymbol.asyncDispose ??= Symbol();\n\n/**\n * Takes a value and a dispose function and returns a new object that implements the Disposable interface.\n * The returned object is the original value augmented with a Symbol.dispose method.\n * @param thing The value to make disposable\n * @param dispose Function to call when disposing the resource\n * @returns The original value with Symbol.dispose method added\n */\nexport function makeResource<T>(thing: T, dispose: () => void): T & Disposable {\n  const it = thing as T & Partial<Disposable>;\n\n  // eslint-disable-next-line no-restricted-syntax\n  const existing = it[Symbol.dispose];\n\n  // eslint-disable-next-line no-restricted-syntax\n  it[Symbol.dispose] = () => {\n    dispose();\n    existing?.();\n  };\n\n  return it as T & Disposable;\n}\n\n/**\n * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.\n * The returned object is the original value augmented with a Symbol.asyncDispose method.\n * @param thing The value to make async disposable\n * @param dispose Async function to call when disposing the resource\n * @returns The original value with Symbol.asyncDispose method added\n */\nexport function makeAsyncResource<T>(\n  thing: T,\n  dispose: () => Promise<void>,\n): T & AsyncDisposable {\n  const it = thing as T & Partial<AsyncDisposable>;\n\n  // eslint-disable-next-line no-restricted-syntax\n  const existing = it[Symbol.asyncDispose];\n\n  // eslint-disable-next-line no-restricted-syntax\n  it[Symbol.asyncDispose] = async () => {\n    await dispose();\n    await existing?.();\n  };\n\n  return it as T & AsyncDisposable;\n}\n"],"mappings":";AAEA,OAAO,YAAY,QAAQ;AAI3B,OAAO,iBAAiB,QAAQ;;;;;;;;AAShC,SAAgB,aAAgBA,OAAUC,SAAqC;CAC7E,MAAM,KAAK;CAGX,MAAM,WAAW,GAAG,OAAO;AAG3B,IAAG,OAAO,WAAW,MAAM;AACzB,WAAS;AACT,cAAY;CACb;AAED,QAAO;AACR;;;;;;;;AASD,SAAgB,kBACdD,OACAE,SACqB;CACrB,MAAM,KAAK;CAGX,MAAM,WAAW,GAAG,OAAO;AAG3B,IAAG,OAAO,gBAAgB,YAAY;AACpC,QAAM,SAAS;AACf,QAAM,YAAY;CACnB;AAED,QAAO;AACR"}