indisposed 0.1.0 → 0.2.0

package/dist/functions/handlers.d.ts

@@ -1,6 +1,6 @@
-import { EventHandlerParams, EventNames, Fn } from '../types';
-import { ChannelOptions } from './channel';
-import { UnpackArray } from './fn';
+import { EventHandlerParams, EventNames, Fn } from '#/types';
+import { ChannelOptions } from '#/functions/channel';
+import { UnpackArray } from '#/functions/fn';
 export type Subscription = (event: any, handler: Fn) => any;
 /**
  * Represents an event emitter with an `off` method for removing listeners.
@@ -94,7 +94,7 @@ export type OnResult<EventEmitter extends HasOn, Event extends EventNames<EventE
  * }
  * ```
  */
-export declare function on<EventEmitter extends HasOn, const Event extends EventNames<EventEmitter["on"]>>(emitter: EventEmitter, event: Event, options?: ChannelOptions): AsyncIterableIterator<UnpackArray<Parameters<import('../types').OverLoadFunctions<EventEmitter["on"]>> extends infer T ? T extends Parameters<import('../types').OverLoadFunctions<EventEmitter["on"]>> ? T extends unknown ? T extends [Event, infer Handler] ? import('../types').ExtractParams<Handler> extends infer P ? P extends any[] ? any[] extends P ? never : P : never : never : never : never : never : never>, undefined, void> & {
+export declare function on<EventEmitter extends HasOn, const Event extends EventNames<EventEmitter["on"]>>(emitter: EventEmitter, event: Event, options?: ChannelOptions): AsyncIterableIterator<UnpackArray<Parameters<import('#/types').OverLoadFunctions<EventEmitter["on"]>> extends infer T ? T extends Parameters<import('#/types').OverLoadFunctions<EventEmitter["on"]>> ? T extends unknown ? T extends [Event, infer Handler] ? import('#/types').ExtractParams<Handler> extends infer P ? P extends any[] ? any[] extends P ? never : P : never : never : never : never : never : never>, undefined, void> & {
     [Symbol.dispose]: () => void;
 } & {
     [Symbol.dispose]: () => void;

package/dist/functions/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/functions/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElE,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,MAAM,CAAC;AAErD,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,KAAK,GAAG,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACpB,GAAG,EAAE,YAAY,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB,EAAE,EAAE,YAAY,CAAC;CACjB,GAAG,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC;CACnB,GAAG,MAAM,CAAC;AAEX,MAAM,MAAM,UAAU,CACrB,YAAY,SAAS,OAAO,EAC5B,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAC9C,OAAO,SAAS,OAAO,IACpB,OAAO,SAAS,IAAI,GACrB,KAAK,GACL,WAAW,CAAC,kBAAkB,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,IAAI,CACnB,YAAY,SAAS,OAAO,EAC5B,KAAK,CAAC,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EACpD,KAAK,CAAC,OAAO,SAAS,OAAO,GAAG,KAAK,EACpC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO;;EAavD;AAED,MAAM,MAAM,QAAQ,CACnB,YAAY,SAAS,KAAK,EAC1B,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IACzC,WAAW,CAAC,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,EAAE,CACjB,YAAY,SAAS,KAAK,EAC1B,KAAK,CAAC,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,EACjD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,cAAc;;;;EAc9D"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/functions/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElE,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,gBAAgB,CAAC;AAE/D,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,KAAK,GAAG,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACpB,GAAG,EAAE,YAAY,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB,EAAE,EAAE,YAAY,CAAC;CACjB,GAAG,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,YAAY,CAAC;CACnB,GAAG,MAAM,CAAC;AAEX,MAAM,MAAM,UAAU,CACrB,YAAY,SAAS,OAAO,EAC5B,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAC9C,OAAO,SAAS,OAAO,IACpB,OAAO,SAAS,IAAI,GACrB,KAAK,GACL,WAAW,CAAC,kBAAkB,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,IAAI,CACnB,YAAY,SAAS,OAAO,EAC5B,KAAK,CAAC,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EACpD,KAAK,CAAC,OAAO,SAAS,OAAO,GAAG,KAAK,EACpC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO;;EAavD;AAED,MAAM,MAAM,QAAQ,CACnB,YAAY,SAAS,KAAK,EAC1B,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IACzC,WAAW,CAAC,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,EAAE,CACjB,YAAY,SAAS,KAAK,EAC1B,KAAK,CAAC,KAAK,SAAS,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,EACjD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,cAAc;;;;EAc9D"}

package/dist/functions/timing.d.ts

@@ -1,4 +1,4 @@
-import { ChannelOptions } from './channel';
+import { ChannelOptions } from '#/functions/channel';
 /**
  * Creates a disposable promise that resolves after a specified delay.
  *

package/dist/functions/timing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../src/functions/timing.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM;;EAKjC;AAED,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;;;;EAY7D"}
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../src/functions/timing.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM;;EAKjC;AAED,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;;;;EAY7D"}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './no-polyfill';
+export * from '#/no-polyfill';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,34 +1,18 @@
-import { channel, interval, invoke, on, once, timeout, toAsyncDisposable, toDisposable } from "./no-polyfill.js";
-const hasNativeDispose = typeof Symbol.dispose === "symbol" && typeof Symbol.asyncDispose === "symbol";
-if (!hasNativeDispose) {
-  try {
-    await import("./explicit-resource-management-BSyjFgS-.js").then((n) => n.e);
-  } catch {
-    console.warn(
-      `Symbol.dispose and Symbol.asyncDispose are not available in this environment.
-			To enable polyfill support, install core-js as a dependency.`
-    );
-  }
+import { a as invoke, c as toDisposable, i as once, n as timeout, o as channel, r as on, s as toAsyncDisposable, t as interval } from "./no-polyfill-D3v5MBct.js";
+//#region src/polyfill.ts
+if (!(typeof Symbol.dispose === "symbol" && typeof Symbol.asyncDispose === "symbol")) try {
+	await import("core-js/proposals/explicit-resource-management");
+} catch {
+	console.warn(`Symbol.dispose and Symbol.asyncDispose are not available in this environment.
+			To enable polyfill support, install core-js as a dependency.`);
 }
-const hasNativeWithResolvers = typeof Promise.withResolvers === "function";
-if (!hasNativeWithResolvers) {
-  try {
-    await import("./with-resolvers-0tPpPN4C.js").then((n) => n.w);
-  } catch {
-    console.warn(
-      `Promise.withResolvers is not available in this environment.
-			To enable polyfill support, install core-js as a dependency.`
-    );
-  }
+if (!(typeof Promise.withResolvers === "function")) try {
+	await import("core-js/actual/promise/with-resolvers");
+} catch {
+	console.warn(`Promise.withResolvers is not available in this environment.
+			To enable polyfill support, install core-js as a dependency.`);
 }
-export {
-  channel,
-  interval,
-  invoke,
-  on,
-  once,
-  timeout,
-  toAsyncDisposable,
-  toDisposable
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { channel, interval, invoke, on, once, timeout, toAsyncDisposable, toDisposable };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/polyfill.ts"],"sourcesContent":["const hasNativeDispose =\n\ttypeof Symbol.dispose === \"symbol\" && typeof Symbol.asyncDispose === \"symbol\";\n\nif (!hasNativeDispose) {\n\ttry {\n\t\t//@ts-expect-error It exists\n\t\tawait import(\"core-js/proposals/explicit-resource-management\");\n\t} catch {\n\t\tconsole.warn(\n\t\t\t`Symbol.dispose and Symbol.asyncDispose are not available in this environment.\n\t\t\tTo enable polyfill support, install core-js as a dependency.`,\n\t\t);\n\t}\n}\n\nconst hasNativeWithResolvers = typeof Promise.withResolvers === \"function\";\n\nif (!hasNativeWithResolvers) {\n\ttry {\n\t\t//@ts-expect-error It exists\n\t\tawait import(\"core-js/actual/promise/with-resolvers\");\n\t} catch {\n\t\tconsole.warn(\n\t\t\t`Promise.withResolvers is not available in this environment.\n\t\t\tTo enable polyfill support, install core-js as a dependency.`,\n\t\t);\n\t}\n}\n"],"names":[],"mappings":";AAAA,MAAM,mBACL,OAAO,OAAO,YAAY,YAAY,OAAO,OAAO,iBAAiB;AAEtE,IAAI,CAAC,kBAAkB;AACtB,MAAI;AAEH,UAAM,OAAO,4CAAgD,EAAA,KAAA,OAAA,EAAA,CAAA;AAAA,EAC9D,QAAQ;AACP,YAAQ;AAAA,MACP;AAAA;AAAA,IAAA;AAAA,EAGF;AACD;AAEA,MAAM,yBAAyB,OAAO,QAAQ,kBAAkB;AAEhE,IAAI,CAAC,wBAAwB;AAC5B,MAAI;AAEH,UAAM,OAAO,8BAAuC,EAAA,KAAA,OAAA,EAAA,CAAA;AAAA,EACrD,QAAQ;AACP,YAAQ;AAAA,MACP;AAAA;AAAA,IAAA;AAAA,EAGF;AACD;"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/polyfill.ts"],"sourcesContent":["const hasNativeDispose =\n\ttypeof Symbol.dispose === \"symbol\" && typeof Symbol.asyncDispose === \"symbol\";\n\nif (!hasNativeDispose) {\n\ttry {\n\t\t//@ts-expect-error It exists\n\t\tawait import(\"core-js/proposals/explicit-resource-management\");\n\t} catch {\n\t\tconsole.warn(\n\t\t\t`Symbol.dispose and Symbol.asyncDispose are not available in this environment.\n\t\t\tTo enable polyfill support, install core-js as a dependency.`,\n\t\t);\n\t}\n}\n\nconst hasNativeWithResolvers = typeof Promise.withResolvers === \"function\";\n\nif (!hasNativeWithResolvers) {\n\ttry {\n\t\t//@ts-expect-error It exists\n\t\tawait import(\"core-js/actual/promise/with-resolvers\");\n\t} catch {\n\t\tconsole.warn(\n\t\t\t`Promise.withResolvers is not available in this environment.\n\t\t\tTo enable polyfill support, install core-js as a dependency.`,\n\t\t);\n\t}\n}\n"],"mappings":";;AAGA,IAAI,EAFH,OAAO,OAAO,YAAY,YAAY,OAAO,OAAO,iBAAiB,WAGrE,IAAI;CAEH,MAAM,OAAO;AACd,QAAQ;CACP,QAAQ,KACP;gEAED;AACD;AAKD,IAAI,EAF2B,OAAO,QAAQ,kBAAkB,aAG/D,IAAI;CAEH,MAAM,OAAO;AACd,QAAQ;CACP,QAAQ,KACP;gEAED;AACD"}

package/dist/no-polyfill-D3v5MBct.js

@@ -0,0 +1,430 @@
+//#region src/functions/disposable.ts
+function hasDisposable(value) {
+	return value != null && typeof value === "object" && typeof value[Symbol.dispose] === "function";
+}
+function hasAsyncDisposable(value) {
+	return value != null && typeof value === "object" && typeof value[Symbol.asyncDispose] === "function";
+}
+/**
+* Make a value disposable by adding a Symbol.dispose method
+* @param value item to make disposable (must be an extensible object)
+* @param disposeFn function that will cleanup the item
+* @returns value that's disposable
+* @example
+* ```ts
+* // Direct usage with extensible objects
+* const resource = toDisposable({ handle: 123 }, (r) => closeHandle(r.handle));
+* using handle = resource; // automatically disposed at end of scope
+*
+* // For non-extensible values (primitives, sealed objects, class instances), wrap them:
+* const connection = new WebSocket('ws://localhost');
+* const disposableConnection = toDisposable(
+*   { socket: connection },
+*   (wrapped) => wrapped.socket.close()
+* );
+* using conn = disposableConnection;
+* ```
+*/
+function toDisposable(value, disposeFn) {
+	let disposed = false;
+	const originalDispose = hasDisposable(value) ? value[Symbol.dispose] : void 0;
+	return Object.assign(value, { [Symbol.dispose]: () => {
+		if (disposed) return;
+		disposeFn(value);
+		originalDispose?.call(value);
+		disposed = true;
+	} });
+}
+/**
+* Make a value async disposable by adding a Symbol.asyncDispose method
+* @param value item to make disposable (must be an extensible object)
+* @param disposeFn async function that will cleanup the item
+* @returns value that's async disposable
+* @example
+* ```ts
+* // Direct usage with extensible objects
+* const resource = toAsyncDisposable({ stream: fs.createReadStream('file.txt') }, async (r) => {
+*   await r.stream.close();
+* });
+* await using file = resource; // automatically disposed at end of scope
+*
+* // For non-extensible values (sealed objects, class instances), wrap them:
+* const database = new DatabaseConnection();
+* const disposableDb = toAsyncDisposable(
+*   { connection: database },
+*   async (wrapped) => {
+*     await wrapped.connection.close();
+*   }
+* );
+* await using db = disposableDb;
+* ```
+*/
+function toAsyncDisposable(value, disposeFn) {
+	let disposingPromise;
+	const originalDispose = hasAsyncDisposable(value) ? value[Symbol.asyncDispose] : void 0;
+	return Object.assign(value, { [Symbol.asyncDispose]: async () => {
+		if (disposingPromise == null) disposingPromise = (async () => {
+			await disposeFn(value);
+			await originalDispose?.call(value);
+		})();
+		await disposingPromise;
+	} });
+}
+//#endregion
+//#region src/functions/channel.ts
+var DEFAULT_OPTIONS = {
+	maxBuffer: 100,
+	drain: false
+};
+/**
+* Creates a buffered async channel for pushing values and consuming them via async iteration.
+*
+* This is a low-level primitive for building async iterators from push-based sources
+* like event emitters, intervals, or any producer that pushes values over time.
+*
+* The returned channel has a `push` method for producers and an `iterator` property
+* for consumers. Only expose the `iterator` to downstream code.
+*
+* @param options - Channel configuration
+* @returns A channel with push capability and a disposable async iterator
+*
+* @example
+* ```ts
+* // Basic usage - producer keeps the channel, consumer gets the iterator
+* const ch = channel<string>();
+*
+* // Producer side
+* ch.push("hello");
+* ch.push("world");
+*
+* // Consumer side - only sees the iterator
+* for await (const value of ch.iterator) {
+*   console.log(value);
+*   if (shouldStop) break;
+* }
+* ```
+*
+* @example
+* ```ts
+* // Building a custom async iterator
+* function myAsyncSource() {
+*   const ch = channel<number>();
+*   // ... set up producer that calls ch.push()
+*   return ch.iterator; // Only expose the iterator
+* }
+* ```
+*/
+function channel(options) {
+	const { maxBuffer, drain: shouldDrain } = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	let closed = false;
+	const events = [];
+	const waiters = [];
+	const doneResult = () => ({
+		value: void 0,
+		done: true
+	});
+	const drainQueue = () => {
+		while (!closed && events.length && waiters.length) {
+			const value = events.shift();
+			waiters.shift()({
+				value,
+				done: false
+			});
+		}
+	};
+	const push = (value) => {
+		if (closed) return;
+		if (maxBuffer <= 0) {
+			if (waiters.length) events.push(value);
+		} else {
+			events.push(value);
+			if (events.length > maxBuffer) events.shift();
+		}
+		drainQueue();
+	};
+	const dispose = () => {
+		if (closed) return;
+		closed = true;
+		if (shouldDrain) while (events.length && waiters.length) {
+			const value = events.shift();
+			waiters.shift()({
+				value,
+				done: false
+			});
+		}
+		while (waiters.length > 0) waiters.shift()?.(doneResult());
+	};
+	return {
+		push,
+		get closed() {
+			return closed;
+		},
+		iterator: {
+			async next() {
+				if (shouldDrain && events.length) return {
+					value: events.shift(),
+					done: false
+				};
+				if (closed) return doneResult();
+				if (events.length) return {
+					value: events.shift(),
+					done: false
+				};
+				return new Promise((resolve) => {
+					waiters.push(resolve);
+					drainQueue();
+				});
+			},
+			return() {
+				dispose();
+				return Promise.resolve(doneResult());
+			},
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.dispose]: dispose
+		}
+	};
+}
+//#endregion
+//#region src/functions/fn.ts
+function unpackArray(values) {
+	return values.length === 0 ? void 0 : values.length === 1 ? values[0] : values;
+}
+/**
+* Utility just invokes the method being called immediately.
+* Useful to scope resources to calling body.
+* @param fn Function to invoke
+* @returns Result of fn
+* @example
+* ```ts
+* import {invoke, once, toAsyncDisposable} from "indisposed";
+* import {WebSocketServer} from "ws";
+*
+* {
+* 	await using wss = await invoke(async () => {
+* 		const wss = toAsyncDisposable(
+* 			new WebSocketServer({ host: "127.0.0.1", port: 0 }),
+* 			(wss) =>
+* 				new Promise((resolve, reject) => {
+* 					wss.close((err) => {
+* 						if (err) return reject(err);
+* 						resolve(undefined);
+* 					});
+* 				}),
+* 		);
+* 		using listening = once(wss, "listening");
+* 		using error = once(wss, "error", true);
+*
+* 		await Promise.race([listening, error]);
+*
+* 		return wss;
+* 	});
+*
+* 	console.log("Server ready at", wss.address());
+* 	// ... handle connections ...
+* }
+* // wss is automatically closed once the scope ends
+* ```
+*/
+function invoke(fn) {
+	return fn();
+}
+//#endregion
+//#region src/functions/handlers.ts
+/**
+* Type-safe wrapper for event emitter's `once` method that preserves overload signatures.
+*
+* The return value is automatically unpacked:
+* - Handlers with 0 parameters resolve to `undefined`
+* - Handlers with 1 parameter resolve to that single value
+* - Handlers with 2+ parameters resolve to an array of values
+*
+* @param emitter - Event emitter with `once` and `off` methods
+* @param event - Event name (must match one of the emitter's overloads)
+* @param rejects - When true, the promise rejects with the handler arguments instead of resolving
+* @returns Disposable promise with the handler arguments and automatic cleanup via `off`
+*
+* @example
+* ```ts
+* type MyEmitter = {
+*   once(event: 'data', handler: (value: string) => void): void;
+*   once(event: 'error', handler: (error: Error) => void): number;
+*   once(event: 'multi', handler: (x: number, y: number) => void): void;
+*   off(event: string, handler: Fn): void;
+* };
+*
+* declare const emitter: MyEmitter;
+*
+* // Single parameter: returns the value directly
+* using result = once(emitter, 'data');
+* console.log((await result).toUpperCase()); // string
+*
+* // Multiple parameters: returns as array
+* using coords = once(emitter, 'multi');
+* const [x, y] = await coords; // [number, number]
+* ```
+*/
+function once(emitter, event, rejects) {
+	const { promise, resolve, reject } = Promise.withResolvers();
+	const handler = (...args) => {
+		if (rejects) {
+			reject(args.length === 1 ? args[0] : args);
+			return;
+		}
+		resolve(unpackArray(args));
+	};
+	emitter.once(event, handler);
+	return toDisposable(promise, () => emitter.off(event, handler));
+}
+/**
+* Type-safe wrapper for event emitter's `on` method that returns an async iterator.
+*
+* The yielded values are automatically unpacked:
+* - Handlers with 0 parameters yield `undefined`
+* - Handlers with 1 parameter yield that single value
+* - Handlers with 2+ parameters yield an array of values
+*
+* @param emitter - Event emitter with `on` and `off` methods
+* @param event - Event name (must match one of the emitter's overloads)
+* @param options - Channel options (maxBuffer, etc.)
+* @returns Disposable async iterator that yields handler arguments
+*
+* @example
+* ```ts
+* type MyEmitter = {
+*   on(event: 'data', handler: (value: string) => void): void;
+*   on(event: 'position', handler: (x: number, y: number) => void): void;
+*   off(event: string, handler: Fn): void;
+* };
+*
+* declare const emitter: MyEmitter;
+*
+* // Single parameter: yields values directly
+* using iterator = on(emitter, 'data');
+* for await (const value of iterator) {
+*   console.log(value.toUpperCase()); // string
+* }
+*
+* // Multiple parameters: yields as array
+* using positions = on(emitter, 'position');
+* for await (const [x, y] of positions) {
+*   console.log(`Position: ${x}, ${y}`);
+* }
+* ```
+*/
+function on(emitter, event, options) {
+	const ch = channel(options);
+	const handler = (...args) => {
+		ch.push(unpackArray(args));
+	};
+	emitter.on(event, handler);
+	return toDisposable(ch.iterator, () => {
+		emitter.off(event, handler);
+	});
+}
+//#endregion
+//#region src/functions/timing.ts
+/**
+* Creates a disposable promise that resolves after a specified delay.
+*
+* The timeout is automatically cleared when disposed, preventing
+* memory leaks and unnecessary timer execution.
+*
+* @param ms - Delay in milliseconds before the promise resolves
+* @returns A disposable promise that resolves to `void` after the delay
+*
+* @example
+* ```ts
+* // Basic usage - wait for 1 second
+* await timeout(1000);
+* console.log("1 second passed");
+* ```
+*
+* @example
+* ```ts
+* // With using - automatically clears timeout when scope exits
+* {
+*   using timer = timeout(5000);
+*   await timer;
+* } // timeout cleared if scope exits early
+* ```
+*
+* @example
+* ```ts
+* // Racing with other promises - losing timeout is cleaned up
+* {
+*   using timer = timeout(10000);
+*   using data = once(socket, "data");
+*
+*   await Promise.race([timer, data]);
+* } // both cleaned up regardless of which wins
+* ```
+*/
+function timeout(ms) {
+	const timingPromise = Promise.withResolvers();
+	const timeoutId = setTimeout(timingPromise.resolve, ms);
+	return toDisposable(timingPromise.promise, () => clearTimeout(timeoutId));
+}
+/**
+* Creates a disposable async iterator that yields incrementing numbers at a fixed interval.
+*
+* Values start at 0 and increment by 1 for each interval tick. The interval
+* is automatically cleared when the iterator is disposed or iteration ends.
+*
+* @param ms - Interval duration in milliseconds between each tick
+* @param options - Channel options for buffering behavior
+* @param options.maxBuffer - Maximum events to buffer (default: 100). Set to 0 for no buffering.
+* @param options.drain - Whether to drain buffer on close (default: false)
+* @returns A disposable async iterator yielding incrementing numbers
+*
+* @example
+* ```ts
+* // Basic usage - tick every second
+* {
+*   using ticks = interval(1000);
+*
+*   for await (const tick of ticks) {
+*     console.log(`Tick ${tick}`); // 0, 1, 2, ...
+*     if (tick >= 5) break;
+*   }
+* } // interval automatically cleared
+* ```
+*
+* @example
+* ```ts
+* // Polling pattern
+* {
+*   using poll = interval(5000);
+*
+*   for await (const _ of poll) {
+*     const status = await checkStatus();
+*     if (status === "complete") break;
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* // With no buffering - only deliver to waiting consumers
+* const ticks = interval(100, { maxBuffer: 0 });
+* ```
+*/
+function interval(ms, options) {
+	const ch = channel(options);
+	let currentValue = 0;
+	const intervalId = setInterval(() => {
+		if (ch.closed) return;
+		ch.push(currentValue++);
+	}, ms);
+	return toDisposable(ch.iterator, () => {
+		clearInterval(intervalId);
+	});
+}
+//#endregion
+export { invoke as a, toDisposable as c, once as i, timeout as n, channel as o, on as r, toAsyncDisposable as s, interval as t };
+
+//# sourceMappingURL=no-polyfill-D3v5MBct.js.map

package/dist/no-polyfill-D3v5MBct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-polyfill-D3v5MBct.js","names":[],"sources":["../src/functions/disposable.ts","../src/functions/channel.ts","../src/functions/fn.ts","../src/functions/handlers.ts","../src/functions/timing.ts"],"sourcesContent":["/** Function that performs cleanup for a disposable resource */\nexport type DisposeFn<T> = (value: T) => unknown;\n\n/**\n * Object with a Symbol.dispose method for automatic cleanup\n * @see {@link toDisposable}\n */\nexport type Disposable<T extends object> = ReturnType<typeof toDisposable<T>>;\n\nfunction hasDisposable(\n\tvalue: unknown,\n): value is { [Symbol.dispose]: () => unknown } {\n\treturn (\n\t\tvalue != null &&\n\t\ttypeof value === \"object\" &&\n\t\ttypeof (value as any)[Symbol.dispose] === \"function\"\n\t);\n}\n\nfunction hasAsyncDisposable(\n\tvalue: unknown,\n): value is { [Symbol.asyncDispose]: () => PromiseLike<unknown> } {\n\treturn (\n\t\tvalue != null &&\n\t\ttypeof value === \"object\" &&\n\t\ttypeof (value as any)[Symbol.asyncDispose] === \"function\"\n\t);\n}\n\n/**\n * Make a value disposable by adding a Symbol.dispose method\n * @param value item to make disposable (must be an extensible object)\n * @param disposeFn function that will cleanup the item\n * @returns value that's disposable\n * @example\n * ```ts\n * // Direct usage with extensible objects\n * const resource = toDisposable({ handle: 123 }, (r) => closeHandle(r.handle));\n * using handle = resource; // automatically disposed at end of scope\n *\n * // For non-extensible values (primitives, sealed objects, class instances), wrap them:\n * const connection = new WebSocket('ws://localhost');\n * const disposableConnection = toDisposable(\n *   { socket: connection },\n *   (wrapped) => wrapped.socket.close()\n * );\n * using conn = disposableConnection;\n * ```\n */\nexport function toDisposable<T extends object>(\n\tvalue: T,\n\tdisposeFn: DisposeFn<T>,\n) {\n\tlet disposed = false;\n\n\tconst originalDispose = hasDisposable(value)\n\t\t? value[Symbol.dispose]\n\t\t: undefined;\n\n\treturn Object.assign(value, {\n\t\t[Symbol.dispose]: () => {\n\t\t\tif (disposed) return;\n\n\t\t\tdisposeFn(value);\n\t\t\toriginalDispose?.call(value);\n\t\t\tdisposed = true;\n\t\t},\n\t});\n}\n\n/** Async function that performs cleanup for a disposable resource */\nexport type AsyncDispose<T> = (value: T) => PromiseLike<unknown>;\n\n/**\n * Object with a Symbol.asyncDispose method for automatic async cleanup\n * @see {@link toAsyncDisposable}\n */\nexport type AsyncDisposable<T extends object> = ReturnType<\n\ttypeof toAsyncDisposable<T>\n>;\n\n/**\n * Make a value async disposable by adding a Symbol.asyncDispose method\n * @param value item to make disposable (must be an extensible object)\n * @param disposeFn async function that will cleanup the item\n * @returns value that's async disposable\n * @example\n * ```ts\n * // Direct usage with extensible objects\n * const resource = toAsyncDisposable({ stream: fs.createReadStream('file.txt') }, async (r) => {\n *   await r.stream.close();\n * });\n * await using file = resource; // automatically disposed at end of scope\n *\n * // For non-extensible values (sealed objects, class instances), wrap them:\n * const database = new DatabaseConnection();\n * const disposableDb = toAsyncDisposable(\n *   { connection: database },\n *   async (wrapped) => {\n *     await wrapped.connection.close();\n *   }\n * );\n * await using db = disposableDb;\n * ```\n */\nexport function toAsyncDisposable<T extends object>(\n\tvalue: T,\n\tdisposeFn: AsyncDispose<T>,\n) {\n\tlet disposingPromise: PromiseLike<unknown> | undefined;\n\tconst originalDispose = hasAsyncDisposable(value)\n\t\t? value[Symbol.asyncDispose]\n\t\t: undefined;\n\n\treturn Object.assign(value, {\n\t\t[Symbol.asyncDispose]: async () => {\n\t\t\tif (disposingPromise == null) {\n\t\t\t\tdisposingPromise = (async () => {\n\t\t\t\t\tawait disposeFn(value);\n\t\t\t\t\tawait originalDispose?.call(value);\n\t\t\t\t})();\n\t\t\t}\n\t\t\tawait disposingPromise;\n\t\t},\n\t});\n}\n","export type ChannelOptions = {\n\t/**\n\t * Maximum amount of events to be buffered.\n\t * When buffer is full, oldest events are dropped.\n\t * Set to 0 to disable buffering (only deliver to waiting consumers).\n\t * @default 100\n\t */\n\tmaxBuffer?: number;\n\n\t/**\n\t * Whether to drain buffered events before ending iteration on dispose.\n\t * When true, buffered events will still be yielded after dispose is called.\n\t * When false, dispose immediately ends iteration and discards buffered events.\n\t * @default false\n\t */\n\tdrain?: boolean;\n};\n\nconst DEFAULT_OPTIONS = {\n\tmaxBuffer: 100,\n\tdrain: false,\n} satisfies ChannelOptions;\n\n/**\n * The iterator portion of a channel - this is what consumers see.\n */\nexport type ChannelIterator<T> = AsyncIterableIterator<T, undefined, void> & {\n\t[Symbol.dispose]: () => void;\n};\n\n/**\n * The full channel handle with push capability - for internal/producer use.\n */\nexport type Channel<T> = {\n\t/**\n\t * Push a value into the channel.\n\t * If there are waiting consumers, the value is delivered immediately.\n\t * Otherwise, it's buffered (subject to maxBuffer).\n\t */\n\tpush: (value: T) => void;\n\t/**\n\t * Whether the channel is closed.\n\t */\n\treadonly closed: boolean;\n\t/**\n\t * The async iterator for consuming values.\n\t * This is what should be exposed to downstream consumers.\n\t */\n\titerator: ChannelIterator<T>;\n};\n\n/**\n * Creates a buffered async channel for pushing values and consuming them via async iteration.\n *\n * This is a low-level primitive for building async iterators from push-based sources\n * like event emitters, intervals, or any producer that pushes values over time.\n *\n * The returned channel has a `push` method for producers and an `iterator` property\n * for consumers. Only expose the `iterator` to downstream code.\n *\n * @param options - Channel configuration\n * @returns A channel with push capability and a disposable async iterator\n *\n * @example\n * ```ts\n * // Basic usage - producer keeps the channel, consumer gets the iterator\n * const ch = channel<string>();\n *\n * // Producer side\n * ch.push(\"hello\");\n * ch.push(\"world\");\n *\n * // Consumer side - only sees the iterator\n * for await (const value of ch.iterator) {\n *   console.log(value);\n *   if (shouldStop) break;\n * }\n * ```\n *\n * @example\n * ```ts\n * // Building a custom async iterator\n * function myAsyncSource() {\n *   const ch = channel<number>();\n *   // ... set up producer that calls ch.push()\n *   return ch.iterator; // Only expose the iterator\n * }\n * ```\n */\nexport function channel<T>(options?: ChannelOptions): Channel<T> {\n\tconst { maxBuffer, drain: shouldDrain } = { ...DEFAULT_OPTIONS, ...options };\n\ttype IterationResult = IteratorResult<T, undefined>;\n\n\tlet closed = false;\n\tconst events: T[] = [];\n\tconst waiters: ((value: IterationResult) => void)[] = [];\n\n\tconst doneResult = (): IterationResult => ({\n\t\tvalue: undefined,\n\t\tdone: true as const,\n\t});\n\n\tconst drainQueue = () => {\n\t\t// Pair off as many as possible, FIFO ↔ FIFO\n\t\twhile (!closed && events.length && waiters.length) {\n\t\t\tconst value = events.shift()!;\n\t\t\tconst resolve = waiters.shift()!;\n\t\t\tresolve({ value, done: false });\n\t\t}\n\t};\n\n\tconst push = (value: T) => {\n\t\tif (closed) return;\n\n\t\tif (maxBuffer <= 0) {\n\t\t\t// Only deliver to waiting consumers\n\t\t\tif (waiters.length) events.push(value);\n\t\t} else {\n\t\t\tevents.push(value);\n\t\t\tif (events.length > maxBuffer) events.shift();\n\t\t}\n\t\tdrainQueue();\n\t};\n\n\tconst dispose = () => {\n\t\tif (closed) return;\n\t\tclosed = true;\n\n\t\tif (shouldDrain) {\n\t\t\t// Drain buffered events to waiting consumers before signaling done\n\t\t\twhile (events.length && waiters.length) {\n\t\t\t\tconst value = events.shift()!;\n\t\t\t\tconst resolve = waiters.shift()!;\n\t\t\t\tresolve({ value, done: false });\n\t\t\t}\n\t\t}\n\n\t\t// Signal done to remaining waiters\n\t\twhile (waiters.length > 0) {\n\t\t\tconst waiter = waiters.shift();\n\t\t\twaiter?.(doneResult());\n\t\t}\n\t};\n\n\tconst iterator: ChannelIterator<T> = {\n\t\tasync next() {\n\t\t\t// If drain mode, return buffered events even after close\n\t\t\tif (shouldDrain && events.length) {\n\t\t\t\treturn { value: events.shift()!, done: false } as const;\n\t\t\t}\n\n\t\t\tif (closed) {\n\t\t\t\treturn doneResult();\n\t\t\t}\n\n\t\t\tif (events.length) {\n\t\t\t\treturn { value: events.shift()!, done: false } as const;\n\t\t\t}\n\n\t\t\t// Wait for the next event\n\t\t\treturn new Promise<IterationResult>((resolve) => {\n\t\t\t\twaiters.push(resolve);\n\t\t\t\tdrainQueue();\n\t\t\t});\n\t\t},\n\t\treturn() {\n\t\t\tdispose();\n\t\t\treturn Promise.resolve(doneResult());\n\t\t},\n\t\t[Symbol.asyncIterator]() {\n\t\t\treturn this;\n\t\t},\n\t\t[Symbol.dispose]: dispose,\n\t};\n\n\treturn {\n\t\tpush,\n\t\tget closed() {\n\t\t\treturn closed;\n\t\t},\n\t\titerator,\n\t};\n}\n","export type UnpackArray<T extends unknown[]> = T[\"length\"] extends 0\n\t? undefined\n\t: T[\"length\"] extends 1\n\t\t? T[0]\n\t\t: T;\n\nexport function unpackArray<T extends unknown[]>(values: T) {\n\treturn (\n\t\tvalues.length === 0 ? undefined : values.length === 1 ? values[0] : values\n\t) as UnpackArray<T>;\n}\n\n/**\n * Utility just invokes the method being called immediately.\n * Useful to scope resources to calling body.\n * @param fn Function to invoke\n * @returns Result of fn\n * @example\n * ```ts\n * import {invoke, once, toAsyncDisposable} from \"indisposed\";\n * import {WebSocketServer} from \"ws\";\n *\n * {\n * \tawait using wss = await invoke(async () => {\n * \t\tconst wss = toAsyncDisposable(\n * \t\t\tnew WebSocketServer({ host: \"127.0.0.1\", port: 0 }),\n * \t\t\t(wss) =>\n * \t\t\t\tnew Promise((resolve, reject) => {\n * \t\t\t\t\twss.close((err) => {\n * \t\t\t\t\t\tif (err) return reject(err);\n * \t\t\t\t\t\tresolve(undefined);\n * \t\t\t\t\t});\n * \t\t\t\t}),\n * \t\t);\n * \t\tusing listening = once(wss, \"listening\");\n * \t\tusing error = once(wss, \"error\", true);\n *\n * \t\tawait Promise.race([listening, error]);\n *\n * \t\treturn wss;\n * \t});\n *\n * \tconsole.log(\"Server ready at\", wss.address());\n * \t// ... handle connections ...\n * }\n * // wss is automatically closed once the scope ends\n * ```\n */\nexport function invoke<TResult>(fn: () => TResult) {\n\treturn fn();\n}\n","import type { EventHandlerParams, EventNames, Fn } from \"#/types\";\nimport { toDisposable } from \"#/functions/disposable\";\nimport { channel, type ChannelOptions } from \"#/functions/channel\";\nimport { type UnpackArray, unpackArray } from \"#/functions/fn\";\n\nexport type Subscription = (event: any, handler: Fn) => any;\n\n/**\n * Represents an event emitter with an `off` method for removing listeners.\n */\nexport type HasOff = {\n\toff: Subscription;\n};\n\n/**\n * Represents an event emitter with an `on` method for registering listeners.\n */\nexport type HasOn = {\n\ton: Subscription;\n} & HasOff;\n\n/**\n * Represents an event emitter with a `once` method for one-time listeners.\n */\nexport type HasOnce = {\n\tonce: Subscription;\n} & HasOff;\n\nexport type OnceResult<\n\tEventEmitter extends HasOnce,\n\tEvent extends EventNames<EventEmitter[\"once\"]>,\n\tRejects extends boolean,\n> = Rejects extends true\n\t? never\n\t: UnpackArray<EventHandlerParams<EventEmitter[\"once\"], Event>>;\n\n/**\n * Type-safe wrapper for event emitter's `once` method that preserves overload signatures.\n *\n * The return value is automatically unpacked:\n * - Handlers with 0 parameters resolve to `undefined`\n * - Handlers with 1 parameter resolve to that single value\n * - Handlers with 2+ parameters resolve to an array of values\n *\n * @param emitter - Event emitter with `once` and `off` methods\n * @param event - Event name (must match one of the emitter's overloads)\n * @param rejects - When true, the promise rejects with the handler arguments instead of resolving\n * @returns Disposable promise with the handler arguments and automatic cleanup via `off`\n *\n * @example\n * ```ts\n * type MyEmitter = {\n *   once(event: 'data', handler: (value: string) => void): void;\n *   once(event: 'error', handler: (error: Error) => void): number;\n *   once(event: 'multi', handler: (x: number, y: number) => void): void;\n *   off(event: string, handler: Fn): void;\n * };\n *\n * declare const emitter: MyEmitter;\n *\n * // Single parameter: returns the value directly\n * using result = once(emitter, 'data');\n * console.log((await result).toUpperCase()); // string\n *\n * // Multiple parameters: returns as array\n * using coords = once(emitter, 'multi');\n * const [x, y] = await coords; // [number, number]\n * ```\n */\nexport function once<\n\tEventEmitter extends HasOnce,\n\tconst Event extends EventNames<EventEmitter[\"once\"]>,\n\tconst Rejects extends boolean = false,\n>(emitter: EventEmitter, event: Event, rejects?: Rejects) {\n\tconst { promise, resolve, reject } =\n\t\tPromise.withResolvers<OnceResult<EventEmitter, Event, Rejects>>();\n\n\tconst handler: Fn = (...args: unknown[]) => {\n\t\tif (rejects) {\n\t\t\treject(args.length === 1 ? args[0] : args);\n\t\t\treturn;\n\t\t}\n\t\tresolve(unpackArray(args) as OnceResult<EventEmitter, Event, Rejects>);\n\t};\n\temitter.once(event, handler);\n\treturn toDisposable(promise, () => emitter.off(event, handler));\n}\n\nexport type OnResult<\n\tEventEmitter extends HasOn,\n\tEvent extends EventNames<EventEmitter[\"on\"]>,\n> = UnpackArray<EventHandlerParams<EventEmitter[\"on\"], Event>>;\n\n/**\n * Type-safe wrapper for event emitter's `on` method that returns an async iterator.\n *\n * The yielded values are automatically unpacked:\n * - Handlers with 0 parameters yield `undefined`\n * - Handlers with 1 parameter yield that single value\n * - Handlers with 2+ parameters yield an array of values\n *\n * @param emitter - Event emitter with `on` and `off` methods\n * @param event - Event name (must match one of the emitter's overloads)\n * @param options - Channel options (maxBuffer, etc.)\n * @returns Disposable async iterator that yields handler arguments\n *\n * @example\n * ```ts\n * type MyEmitter = {\n *   on(event: 'data', handler: (value: string) => void): void;\n *   on(event: 'position', handler: (x: number, y: number) => void): void;\n *   off(event: string, handler: Fn): void;\n * };\n *\n * declare const emitter: MyEmitter;\n *\n * // Single parameter: yields values directly\n * using iterator = on(emitter, 'data');\n * for await (const value of iterator) {\n *   console.log(value.toUpperCase()); // string\n * }\n *\n * // Multiple parameters: yields as array\n * using positions = on(emitter, 'position');\n * for await (const [x, y] of positions) {\n *   console.log(`Position: ${x}, ${y}`);\n * }\n * ```\n */\nexport function on<\n\tEventEmitter extends HasOn,\n\tconst Event extends EventNames<EventEmitter[\"on\"]>,\n>(emitter: EventEmitter, event: Event, options?: ChannelOptions) {\n\ttype Item = OnResult<EventEmitter, Event>;\n\n\tconst ch = channel<Item>(options);\n\n\tconst handler = (...args: unknown[]) => {\n\t\tch.push(unpackArray(args) as Item);\n\t};\n\n\temitter.on(event, handler);\n\n\treturn toDisposable(ch.iterator, () => {\n\t\temitter.off(event, handler);\n\t});\n}\n","import { toDisposable } from \"#/functions/disposable\";\nimport { channel, type ChannelOptions } from \"#/functions/channel\";\n\n/**\n * Creates a disposable promise that resolves after a specified delay.\n *\n * The timeout is automatically cleared when disposed, preventing\n * memory leaks and unnecessary timer execution.\n *\n * @param ms - Delay in milliseconds before the promise resolves\n * @returns A disposable promise that resolves to `void` after the delay\n *\n * @example\n * ```ts\n * // Basic usage - wait for 1 second\n * await timeout(1000);\n * console.log(\"1 second passed\");\n * ```\n *\n * @example\n * ```ts\n * // With using - automatically clears timeout when scope exits\n * {\n *   using timer = timeout(5000);\n *   await timer;\n * } // timeout cleared if scope exits early\n * ```\n *\n * @example\n * ```ts\n * // Racing with other promises - losing timeout is cleaned up\n * {\n *   using timer = timeout(10000);\n *   using data = once(socket, \"data\");\n *\n *   await Promise.race([timer, data]);\n * } // both cleaned up regardless of which wins\n * ```\n */\nexport function timeout(ms: number) {\n\tconst timingPromise = Promise.withResolvers<void>();\n\tconst timeoutId = setTimeout(timingPromise.resolve, ms);\n\n\treturn toDisposable(timingPromise.promise, () => clearTimeout(timeoutId));\n}\n\nexport type IntervalOptions = ChannelOptions;\n\n/**\n * Creates a disposable async iterator that yields incrementing numbers at a fixed interval.\n *\n * Values start at 0 and increment by 1 for each interval tick. The interval\n * is automatically cleared when the iterator is disposed or iteration ends.\n *\n * @param ms - Interval duration in milliseconds between each tick\n * @param options - Channel options for buffering behavior\n * @param options.maxBuffer - Maximum events to buffer (default: 100). Set to 0 for no buffering.\n * @param options.drain - Whether to drain buffer on close (default: false)\n * @returns A disposable async iterator yielding incrementing numbers\n *\n * @example\n * ```ts\n * // Basic usage - tick every second\n * {\n *   using ticks = interval(1000);\n *\n *   for await (const tick of ticks) {\n *     console.log(`Tick ${tick}`); // 0, 1, 2, ...\n *     if (tick >= 5) break;\n *   }\n * } // interval automatically cleared\n * ```\n *\n * @example\n * ```ts\n * // Polling pattern\n * {\n *   using poll = interval(5000);\n *\n *   for await (const _ of poll) {\n *     const status = await checkStatus();\n *     if (status === \"complete\") break;\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * // With no buffering - only deliver to waiting consumers\n * const ticks = interval(100, { maxBuffer: 0 });\n * ```\n */\nexport function interval(ms: number, options?: IntervalOptions) {\n\tconst ch = channel<number>(options);\n\tlet currentValue = 0;\n\n\tconst intervalId = setInterval(() => {\n\t\tif (ch.closed) return;\n\t\tch.push(currentValue++);\n\t}, ms);\n\n\treturn toDisposable(ch.iterator, () => {\n\t\tclearInterval(intervalId);\n\t});\n}\n"],"mappings":"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"}

package/dist/no-polyfill.d.ts

@@ -1,6 +1,6 @@
-export * from './functions/disposable';
-export * from './functions/handlers';
-export * from './functions/channel';
-export * from './functions/timing';
-export { invoke } from './functions/fn';
+export * from '#/functions/disposable';
+export * from '#/functions/handlers';
+export * from '#/functions/channel';
+export * from '#/functions/timing';
+export { invoke } from '#/functions/fn';
 //# sourceMappingURL=no-polyfill.d.ts.map