indisposed 0.0.8 → 0.2.0

package/README.md

@@ -10,6 +10,8 @@ The missing utilities for JavaScript's [Explicit Resource Management](https://gi
 
 - 🧹 **Resource Management** - Convert any resource into a disposable with `toDisposable` and `toAsyncDisposable`
 - 🎧 **Event Handlers** - Transform event emitters into disposable iterators with `on` and promises with `once`
+- ⏱️ **Timing Utilities** - Disposable `timeout` and `interval` for clean timer management
+- 📡 **Channels** - Build async iterators from push-based sources with `channel`
 - 🔒 **Scoped Execution** - Execute code with automatic cleanup using `invoke`
 - 📦 **Zero Dependencies** - Lightweight and focused
 - 🔧 **TypeScript First** - Full type safety and inference
@@ -133,7 +135,7 @@ import { once } from "indisposed";
 }
 ```
 
-### `on(emitter, event, maxBuffer?)`
+### `on(emitter, event, options?)`
 
 Create a disposable async iterator for multiple events.
 
@@ -164,6 +166,109 @@ import { on } from "indisposed";
 		console.log(`Position: ${x}, ${y}`);
 	}
 }
+
+// With buffer options
+{
+	using events = on(emitter, "data", { maxBuffer: 10, drain: true });
+	// ...
+}
+```
+
+### `timeout(ms)`
+
+Create a disposable promise that resolves after a delay.
+
+```typescript
+import { timeout } from "indisposed";
+
+// Basic usage
+await timeout(1000);
+console.log("1 second passed");
+
+// With using - automatically clears timeout when scope exits
+{
+	using timer = timeout(5000);
+	await timer;
+} // timeout cleared if scope exits early
+
+// Racing with other promises
+{
+	using timer = timeout(10000);
+	using data = once(socket, "data");
+
+	await Promise.race([timer, data]);
+} // both cleaned up regardless of which wins
+```
+
+### `interval(ms, options?)`
+
+Create a disposable async iterator that yields incrementing numbers at a fixed interval.
+
+```typescript
+import { interval } from "indisposed";
+
+// 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
+
+// Polling pattern
+{
+	using poll = interval(5000);
+
+	for await (const _ of poll) {
+		const status = await checkStatus();
+		if (status === "complete") break;
+	}
+}
+
+// With options
+const ticks = interval(100, { maxBuffer: 10, drain: true });
+```
+
+### `channel<T>(options?)`
+
+Create 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.
+The channel separates producer (`push`) and consumer (`iterator`) concerns - only expose
+the `iterator` to downstream code.
+
+**Options:**
+
+- `maxBuffer` - Maximum events to buffer (default: 100). Set to 0 for no buffering.
+- `drain` - Whether to drain buffered events on dispose (default: false)
+
+```typescript
+import { channel } from "indisposed";
+
+// 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
+{
+	using iter = ch.iterator;
+	for await (const value of iter) {
+		console.log(value);
+		if (shouldStop) break;
+	}
+}
+
+// Building a custom async source
+function createDataStream() {
+	const ch = channel<Data>();
+	source.on("data", (d) => ch.push(d));
+	return ch.iterator; // Only expose the iterator
+}
 ```
 
 ### `invoke<T>(fn)`

package/dist/functions/channel.d.ts

@@ -0,0 +1,82 @@
+export type ChannelOptions = {
+    /**
+     * Maximum amount of events to be buffered.
+     * When buffer is full, oldest events are dropped.
+     * Set to 0 to disable buffering (only deliver to waiting consumers).
+     * @default 100
+     */
+    maxBuffer?: number;
+    /**
+     * Whether to drain buffered events before ending iteration on dispose.
+     * When true, buffered events will still be yielded after dispose is called.
+     * When false, dispose immediately ends iteration and discards buffered events.
+     * @default false
+     */
+    drain?: boolean;
+};
+/**
+ * The iterator portion of a channel - this is what consumers see.
+ */
+export type ChannelIterator<T> = AsyncIterableIterator<T, undefined, void> & {
+    [Symbol.dispose]: () => void;
+};
+/**
+ * The full channel handle with push capability - for internal/producer use.
+ */
+export type Channel<T> = {
+    /**
+     * Push a value into the channel.
+     * If there are waiting consumers, the value is delivered immediately.
+     * Otherwise, it's buffered (subject to maxBuffer).
+     */
+    push: (value: T) => void;
+    /**
+     * Whether the channel is closed.
+     */
+    readonly closed: boolean;
+    /**
+     * The async iterator for consuming values.
+     * This is what should be exposed to downstream consumers.
+     */
+    iterator: ChannelIterator<T>;
+};
+/**
+ * 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
+ * }
+ * ```
+ */
+export declare function channel<T>(options?: ChannelOptions): Channel<T>;
+//# sourceMappingURL=channel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/functions/channel.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC5B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAOF;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,qBAAqB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG;IAC5E,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACxB;;;;OAIG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,CA6F/D"}

package/dist/functions/handlers.d.ts

@@ -1,5 +1,6 @@
-import { EventHandlerParams, EventNames, Fn } from '../types';
-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.
@@ -67,7 +68,7 @@ export type OnResult<EventEmitter extends HasOn, Event extends EventNames<EventE
  *
  * @param emitter - Event emitter with `on` and `off` methods
  * @param event - Event name (must match one of the emitter's overloads)
- * @param maxBuffer - Maximum number of events to buffer (default: 100)
+ * @param options - Channel options (maxBuffer, etc.)
  * @returns Disposable async iterator that yields handler arguments
  *
  * @example
@@ -93,7 +94,9 @@ 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, maxBuffer?: number): 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;
 };
 //# sourceMappingURL=handlers.d.ts.map

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,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,SAAS,SAAM;;EA0ErD"}
+{"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

@@ -0,0 +1,91 @@
+import { ChannelOptions } from '#/functions/channel';
+/**
+ * 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
+ * ```
+ */
+export declare function timeout(ms: number): Promise<void> & {
+    [Symbol.dispose]: () => void;
+};
+export type IntervalOptions = ChannelOptions;
+/**
+ * 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 });
+ * ```
+ */
+export declare function interval(ms: number, options?: IntervalOptions): AsyncIterableIterator<number, undefined, void> & {
+    [Symbol.dispose]: () => void;
+} & {
+    [Symbol.dispose]: () => void;
+};
+//# sourceMappingURL=timing.d.ts.map

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

@@ -0,0 +1 @@
+{"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,31 +1,18 @@
-import { invoke, on, once, 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 {
-  invoke,
-  on,
-  once,
-  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"}