@alwatr/delay 5.5.11 → 6.0.0

package/CHANGELOG.md

@@ -3,6 +3,43 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [6.0.0](https://github.com/Alwatr/nanolib/compare/@alwatr/delay@5.5.11...@alwatr/delay@6.0.0) (2025-09-08)
+
+### ⚠ BREAKING CHANGES
+
+* **delay:** The API has been completely redesigned. All previous standalone functions are removed and replaced by methods on the `delay` object.
+
+- **REMOVED:**
+  - `untilNextAnimationFrame`
+  - `untilIdle`
+  - `untilDomEvent`
+  - `untilEvent`
+  - `immediate`
+  - `nextMicrotask`
+
+- **ADDED:**
+  - `delay.animationFrame` (replaces `waitForAnimationFrame`)
+  - `delay.idleCallback` (replaces `waitForIdle`)
+  - `delay.domEvent` (replaces `waitForDomEvent`)
+  - `delay.event` (replaces `waitForEvent`)
+  - `delay.nextMacrotask` (replaces `waitForImmediate`)
+  - `delay.nextMicrotask` (replaces `waitForMicrotask`)
+
+Users must update their code to import the `delay` object and use the new method names. For example, `delay.immediate()` should be changed to `delay.nextMacrotask()`.
+
+### ✨ Features
+
+* **delay:** Overhaul delay module with improved API and corrected implementations ([7c12483](https://github.com/Alwatr/nanolib/commit/7c1248354f2535a65cb7981c42ad4e319badb4aa))
+
+### 🔨 Code Refactoring
+
+* **polyfill:** rename global_ to globalThis for clarity and consistency ([7d1484f](https://github.com/Alwatr/nanolib/commit/7d1484fb91a66d46b62011d0fb7825f3089183f8))
+* **polyfill:** streamline requestAnimationFrame and requestIdleCallback implementations ([d18443d](https://github.com/Alwatr/nanolib/commit/d18443d4dedddff8f54227aa7aff2bca5aaacdfa))
+
+### 🧹 Miscellaneous Chores
+
+* **main:** export requestAnimationFrame and requestIdleCallback from main module ([ef80797](https://github.com/Alwatr/nanolib/commit/ef80797319e3bded5c36e98352b6317427d08a59))
+
 ## [5.5.11](https://github.com/Alwatr/nanolib/compare/@alwatr/delay@5.5.10...@alwatr/delay@5.5.11) (2025-09-06)
 
 **Note:** Version bump only for package @alwatr/delay

package/README.md

@@ -1,106 +1,109 @@
 # @alwatr/delay
 
-`@alwatr/delay` offers a collection of utility functions to handle asynchronous execution flow effectively. It allows you to pause your code until specific conditions are met or certain events occur. This functionality aids in managing complex asynchronous scenarios and crafting intricate flows with ease. The functions can be used independently or combined for robust control over asynchronous operations.
+A robust and lightweight utility library for managing asynchronous operations in JavaScript and TypeScript. `@alwatr/delay` provides a collection of promise-based functions to pause execution until specific conditions are met, such as timeouts, animation frames, idle callbacks, or DOM events. This helps create clean, readable, and predictable asynchronous code.
 
 ## Installation
 
 ```bash
+# Using npm
 npm install @alwatr/delay
-```
 
-```bash
+# Using yarn
 yarn add @alwatr/delay
 ```
 
 ## Usage
 
-Each function within `@alwatr/delay` returns a Promise that resolves when the specified waiting condition is met. Here's a breakdown of the available functions:
-
-- **waitForTimeout(duration: number): Promise<void>**
-
-  - Waits for a specified duration (in milliseconds) before resolving.
-  - Example:
+All functions are available under the `delay` object and return a `Promise`. You can use them with `async/await` for clean and linear code flow.
 
-    ```typescript
-    import {waitForTimeout} from '@alwatr/delay';
+```typescript
+import {delay} from '@alwatr/delay';
 
-    await waitForTimeout(1000); // Waits for 1 second
-    ```
-
-- **waitForAnimationFrame(): Promise<DOMHighResTimeStamp>**
-
-  - Pauses execution until the next animation frame is scheduled, resolving with the current timestamp.
-  - Useful for synchronizing UI updates with browser rendering.
-  - Example:
+async function main() {
+  console.log('Waiting for 1 second...');
+  await delay.by('1s');
+  console.log('Done.');
+}
+```
 
-    ```typescript
-    import {waitForAnimationFrame} from '@alwatr/delay';
+### API Reference
 
-    await waitForAnimationFrame(); // Waits for next animation frame
-    ```
+- **`delay.by(duration: Duration): Promise<void>`**
 
-- **waitForIdle(timeout?: number): Promise<IdleDeadline>**
+  Pauses execution for a specified duration. The duration can be a number (in milliseconds) or a string (e.g., `'2s'`, `'500ms'`).
 
-  - Waits for the next idle period (when the browser is not busy), resolving with an `IdleDeadline` object.
-  - Optionally accepts a timeout value (in milliseconds) for maximum waiting time.
-  - Ideal for executing tasks that don't impact user experience.
-  - Example:
+  ```typescript
+  await delay.by(2000); // Waits for 2 seconds
+  await delay.by('5m'); // Waits for 5 minutes
+  ```
 
-    ```typescript
-    import {waitForIdle} from '@alwatr/delay';
+- **`delay.animationFrame(): Promise<DOMHighResTimeStamp>`**
 
-    await waitForIdle(); // Waits for next idle period
-    ```
+  Resolves at the beginning of the next browser animation frame. Useful for synchronizing animations and DOM updates with the browser's rendering cycle to avoid layout thrashing.
 
-- **waitForDomEvent<T extends keyof HTMLElementEventMap>(element: HTMLElement, eventName: T): Promise<HTMLElementEventMap[T]>**
+  ```typescript
+  const timestamp = await delay.animationFrame();
+  console.log(`Rendering next frame at ${timestamp}`);
+  // Perform DOM updates here
+  ```
 
-  - Pauses execution until a specific DOM event is triggered on a provided element, resolving with the event object.
-  - Example:
+- **`delay.idleCallback(options?: IdleRequestOptions): Promise<IdleDeadline>`**
 
-    ```typescript
-    import {waitForDomEvent} from '@alwatr/delay';
+  Resolves when the browser's event loop is idle. Ideal for deferring non-critical background tasks to avoid impacting user experience.
 
-    const button = document.getElementById('myButton');
-    await waitForDomEvent(button, 'click'); // Waits for click event on button
-    ```
+  ```typescript
+  const deadline = await delay.idleCallback({timeout: 1000});
+  if (!deadline.didTimeout) {
+    console.log('Running background task during idle time.');
+  }
+  ```
 
-- **waitForEvent(target: HasAddEventListener, eventName: string): Promise<Event>**
+- **`delay.domEvent<T extends keyof HTMLElementEventMap>(element: HTMLElement, eventName: T, options?: AddEventListenerOptions): Promise<HTMLElementEventMap[T]>`**
 
-  - More generic version of `waitForDomEvent`, allowing waiting for any event on any object with an `addEventListener` method.
-  - Example:
+  Waits for a specific DOM event to be dispatched on an `HTMLElement`.
 
-    ```typescript
-    import {waitForEvent} from '@alwatr/delay';
+  ```typescript
+  const button = document.getElementById('my-button');
+  if (button) {
+    const event = await delay.domEvent(button, 'click');
+    console.log('Button was clicked!', event);
+  }
+  ```
 
-    const server = http.createServer();
-    await waitForEvent(server, 'request'); // Waits for request event on server
-    ```
+- **`delay.event(target: EventTarget, eventName: string, options?: AddEventListenerOptions): Promise<Event>`**
 
-- **waitForImmediate(): Promise<void>**
+  A more generic version of `domEvent`. Waits for any event on any `EventTarget` (e.g., `window`, `document`, or custom event emitters).
 
-  - Executes the next task in the microtask queue immediately after the current task finishes.
-  - Example:
+  ```typescript
+  console.log('Waiting for window resize...');
+  await delay.event(window, 'resize');
+  console.log('Window was resized!');
+  ```
 
-    ```typescript
-    import {waitForImmediate} from '@alwatr/delay';
+- **`delay.nextMacrotask(): Promise<void>`**
 
-    await waitForImmediate(); // Executes next microtask
-    ```
+  Schedules a macrotask to run in the next cycle of the event loop. This is useful for yielding control back to the browser, allowing it to handle rendering and other user-facing tasks. Implemented with `setTimeout(..., 0)`.
 
-- **waitForMicrotask(): Promise<void>**
+  ```typescript
+  console.log('A');
+  await delay.nextMacrotask();
+  console.log('B'); // This will log after 'A' and after the browser has had a chance to breathe.
+  ```
 
-  - Similar to `waitForImmediate`, but waits specifically for the next microtask queue.
-  - Example:
+- **`delay.nextMicrotask(): Promise<void>`**
 
-    ```typescript
-    import {waitForMicrotask} from '@alwatr/delay';
+  Queues a microtask to be executed immediately after the current task completes, before the event loop proceeds to the next macrotask. Useful for scheduling work that needs to happen synchronously after an operation but without blocking the main thread.
 
-    await waitForMicrotask(); // Waits for next microtask queue
-    ```
+  ```typescript
+  console.log('A');
+  Promise.resolve().then(() => console.log('C'));
+  await delay.nextMicrotask();
+  console.log('B'); // Logs A, C, B
+  ```
 
 ## Contributing
 
-We welcome contributions to improve this package! Feel free to open bug reports, suggest new features, or submit pull requests following our [contribution guidelines](https://github.com/Alwatr/.github/blob/next/CONTRIBUTING.md).
+Contributions are welcome\! Please feel free to open an issue or submit a pull request. Read our [contribution guidelines](https://github.com/Alwatr/.github/blob/next/CONTRIBUTING.md) to get started.
 
 ## Sponsors
 

package/dist/main.cjs

@@ -1,4 +1,4 @@
-/* @alwatr/delay v5.5.11 */
+/* @alwatr/delay v6.0.0 */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/main.ts
 var main_exports = {};
 __export(main_exports, {
-  delay: () => delay
+  delay: () => delay,
+  requestAnimationFrame: () => requestAnimationFrame,
+  requestIdleCallback: () => requestIdleCallback
 });
 module.exports = __toCommonJS(main_exports);
 var import_package_tracer = require("@alwatr/package-tracer");
@@ -29,127 +31,139 @@ var import_parse_duration = require("@alwatr/parse-duration");
 
 // src/polyfill.ts
 var import_global_this = require("@alwatr/global-this");
-var win = /* @__PURE__ */ (0, import_global_this.getGlobalThis)();
-var requestAnimationFrameFallback = (callback) => setTimeout(() => callback(Date.now()), 1e3 / 60);
-var requestAnimationFrame = /* @__PURE__ */ (() => win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || requestAnimationFrameFallback)();
-var requestIdleCallbackFallback = (callback, options) => setTimeout(callback, options?.timeout ?? 2e3);
-var requestIdleCallback = /* @__PURE__ */ (() => win.requestIdleCallback || win.webkitRequestIdleCallback || win.mozRequestIdleCallback || requestIdleCallbackFallback)();
+var globalThis = /* @__PURE__ */ (0, import_global_this.getGlobalThis)();
+var requestAnimationFrame = /* @__PURE__ */ globalThis.requestAnimationFrame?.bind(globalThis) ?? ((callback) => setTimeout(() => callback(performance.now()), 1e3 / 60));
+var requestIdleCallback = /* @__PURE__ */ globalThis.requestIdleCallback?.bind(globalThis) ?? ((callback, options) => {
+  const startTime = Date.now();
+  return setTimeout(() => {
+    callback({
+      didTimeout: !!options?.timeout,
+      timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime))
+    });
+  }, options?.timeout ?? 20);
+});
 
 // src/main.ts
-__dev_mode__: import_package_tracer.packageTracer.add("@alwatr/delay", "5.5.11");
+__dev_mode__: import_package_tracer.packageTracer.add("@alwatr/delay", "6.0.0");
 var delay = {
   /**
-   * Delays execution for a specified duration (in milliseconds).
+   * Pauses execution for a specified duration.
    *
-   * @param duration - The duration to wait (in milliseconds). Use `0` to yield control to the event loop.
+   * @param duration The duration to wait. Can be a number in milliseconds or a string like '2s', '100ms'.
    * @returns A Promise that resolves after the specified duration.
    *
    * @example
    * ```typescript
    * await delay.by('1m'); // Wait for 1 minute
+   * await delay.by('2s'); // Wait for 2 seconds
    * ```
    */
   by: (duration) => new Promise((resolve) => setTimeout(resolve, (0, import_parse_duration.parseDuration)(duration))),
   /**
-   * Delays execution until the next animation frame.
+   * Pauses execution until the next animation frame.
    *
-   * @returns A Promise that resolves with the current timestamp when the next animation frame is fired.
+   * @returns A Promise that resolves with the high-resolution timestamp of the next animation frame.
    *
    * @example
    * ```typescript
-   * const timestamp = await delay.untilNextAnimationFrame();
+   * const timestamp = await delay.animationFrame();
+   * console.log(`Next frame at ${timestamp}`);
    * ```
    */
-  untilNextAnimationFrame: () => new Promise((resolve) => requestAnimationFrame(resolve)),
+  animationFrame: () => new Promise((resolve) => requestAnimationFrame(resolve)),
   /**
-   * Delays execution until the browser's idle period or the specified timeout.
+   * Pauses execution until the browser is idle.
    *
-   * @param timeout - Optional timeout (in milliseconds) for the idle callback.
-   * @returns A Promise that resolves with the IdleDeadline object when the browser is idle or the timeout is reached.
+   * @param timeout An optional maximum duration to wait.
+   * @returns A Promise that resolves with an `IdleDeadline` object.
    *
    * @example
    * ```typescript
-   * const deadline = await delay.untilIdle();
+   * const deadline = await delay.idleCallback({ timeout: 2000 });
+   * if (deadline.didTimeout) {
+   * console.log('Idle callback timed out.');
+   * }
    * ```
    */
-  untilIdle: (timeout) => new Promise((resolve) => requestIdleCallback(resolve, timeout === void 0 ? void 0 : {
-    timeout: (0, import_parse_duration.parseDuration)(timeout)
-  })),
+  idleCallback: (options) => new Promise((resolve) => requestIdleCallback(resolve, options)),
   /**
-   * Delays execution until a specific DOM event occurs on an HTMLElement.
+   * Pauses execution until a specific DOM event is dispatched on an element.
    *
-   * @param element - The HTMLElement to listen for the event on.
-   * @param eventName - The name of the DOM event to wait for.
-   * @template T The event map type.
-   * @returns A Promise that resolves with the event object when the specified event occurs.
+   * @param element The HTMLElement to listen on.
+   * @param eventName The name of the event to wait for.
+   * @param options Optional event listener options.
+   * @template T The event map type for the element.
+   * @returns A Promise that resolves with the triggered event object.
    *
    * @example
    * ```typescript
-   * const clickEvent = await delay.untilDomEvent(document.body, 'click');
+   * const button = document.getElementById('my-button');
+   * if (button) {
+   * const clickEvent = await delay.domEvent(button, 'click');
+   * console.log('Button clicked!', clickEvent);
+   * }
    * ```
    */
-  untilDomEvent: (element, eventName) => new Promise(
-    (resolve) => element.addEventListener(eventName, resolve, { once: true, passive: true })
+  domEvent: (element, eventName, options = { passive: true }) => new Promise(
+    (resolve) => element.addEventListener(eventName, resolve, {
+      ...options,
+      once: true
+    })
   ),
   /**
-   * Delays execution until a specific event occurs on an object with an `addEventListener` method.
+   * Pauses execution until a specific event is dispatched on any event target.
    *
-   * @param target - The target object to listen for the event on.
-   * @param eventName - The name of the event to wait for.
-   * @returns A Promise that resolves with the event object when the specified event occurs.
+   * @param target The event target (e.g., window, document, or a custom event emitter).
+   * @param eventName The name of the event to wait for.
+   * @param options Optional event listener options.
+   * @returns A Promise that resolves with the triggered event object.
    *
    * @example
    * ```typescript
-   * const server = http.createServer();
-   * const requestEvent = await delay.untilEvent(server, 'request');
+   * const resizeEvent = await delay.event(window, 'resize');
+   * console.log('Window resized:', resizeEvent);
    * ```
    */
-  untilEvent: (target, eventName) => new Promise(
-    (resolve) => target.addEventListener(eventName, resolve, { once: true, passive: true })
+  event: (target, eventName, options = { passive: true }) => new Promise(
+    (resolve) => target.addEventListener(eventName, resolve, {
+      ...options,
+      once: true
+    })
   ),
   /**
-   * Yields control to the event loop immediately.
-   *
-   * Uses `setImmediate` if available, falls back to `queueMicrotask`, and then to `setTimeout(0)`.
+   * Schedules a macrotask to run after the current event loop task completes.
+   * Uses `setTimeout(..., 0)`.
    *
-   * @returns A Promise that resolves immediately after yielding control to the event loop.
+   * @returns A Promise that resolves when the macrotask is executed.
    *
    * @example
    * ```typescript
-   * await delay.immediate();
+   * console.log('Start');
+   * await delay.nextMacrotask();
+   * console.log('End - after current task');
    * ```
    */
-  immediate: () => {
-    if (typeof setImmediate !== "function") {
-      if (typeof queueMicrotask === "function") {
-        return delay.nextMicrotask();
-      }
-      return delay.by(0);
-    }
-    return new Promise((resolve) => setImmediate(resolve));
-  },
+  nextMacrotask: () => new Promise((resolve) => setTimeout(resolve, 0)),
   /**
-   * Delays execution until the next microtask queue is empty
+   * Queues a microtask to run after the current task completes but before the next macrotask.
    *
-   * @returns A Promise that resolves when the next microtask queue is empty.
+   * @returns A Promise that resolves when the microtask is executed.
    *
    * @example
    * ```typescript
+   * console.log('Start');
    * await delay.nextMicrotask();
+   * console.log('End - immediately after current task');
    * ```
    */
-  nextMicrotask: () => {
-    if (typeof queueMicrotask !== "function") {
-      if (typeof setImmediate === "function") {
-        return delay.immediate();
-      }
-      return delay.by(0);
-    }
-    return new Promise((resolve) => queueMicrotask(resolve));
-  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  nextMicrotask: () => Promise.resolve().then(() => {
+  })
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  delay
+  delay,
+  requestAnimationFrame,
+  requestIdleCallback
 });
 //# sourceMappingURL=main.cjs.map

package/dist/main.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/main.ts", "../src/polyfill.ts"],
-  "sourcesContent": ["import {packageTracer} from '@alwatr/package-tracer';\nimport {parseDuration, type Duration} from '@alwatr/parse-duration';\n\n__dev_mode__: packageTracer.add(__package_name__, __package_version__);\n\nimport {requestAnimationFrame, requestIdleCallback} from './polyfill.js';\n\n/**\n * A utility module to help manage asynchronous operations and waiting for events or timeouts.\n */\nexport const delay = {\n  /**\n   * Delays execution for a specified duration (in milliseconds).\n   *\n   * @param duration - The duration to wait (in milliseconds). Use `0` to yield control to the event loop.\n   * @returns A Promise that resolves after the specified duration.\n   *\n   * @example\n   * ```typescript\n   * await delay.by('1m'); // Wait for 1 minute\n   * ```\n   */\n  by: (duration: Duration): Promise<void> =>\n    new Promise((resolve) => setTimeout(resolve, parseDuration(duration))),\n\n  /**\n   * Delays execution until the next animation frame.\n   *\n   * @returns A Promise that resolves with the current timestamp when the next animation frame is fired.\n   *\n   * @example\n   * ```typescript\n   * const timestamp = await delay.untilNextAnimationFrame();\n   * ```\n   */\n  untilNextAnimationFrame: (): Promise<DOMHighResTimeStamp> =>\n    new Promise((resolve) => requestAnimationFrame(resolve)),\n\n  /**\n   * Delays execution until the browser's idle period or the specified timeout.\n   *\n   * @param timeout - Optional timeout (in milliseconds) for the idle callback.\n   * @returns A Promise that resolves with the IdleDeadline object when the browser is idle or the timeout is reached.\n   *\n   * @example\n   * ```typescript\n   * const deadline = await delay.untilIdle();\n   * ```\n   */\n  untilIdle: (timeout?: Duration): Promise<IdleDeadline> =>\n    new Promise((resolve) => requestIdleCallback(resolve, timeout === undefined ? undefined : {\n      timeout: parseDuration(timeout)\n    })),\n\n  /**\n   * Delays execution until a specific DOM event occurs on an HTMLElement.\n   *\n   * @param element - The HTMLElement to listen for the event on.\n   * @param eventName - The name of the DOM event to wait for.\n   * @template T The event map type.\n   * @returns A Promise that resolves with the event object when the specified event occurs.\n   *\n   * @example\n   * ```typescript\n   * const clickEvent = await delay.untilDomEvent(document.body, 'click');\n   * ```\n   */\n  untilDomEvent: <T extends keyof HTMLElementEventMap>(\n    element: HTMLElement,\n    eventName: T\n  ): Promise<HTMLElementEventMap[T]> =>\n    new Promise((resolve) =>\n      element.addEventListener(eventName, resolve, { once: true, passive: true })\n    ),\n\n  /**\n   * Delays execution until a specific event occurs on an object with an `addEventListener` method.\n   *\n   * @param target - The target object to listen for the event on.\n   * @param eventName - The name of the event to wait for.\n   * @returns A Promise that resolves with the event object when the specified event occurs.\n   *\n   * @example\n   * ```typescript\n   * const server = http.createServer();\n   * const requestEvent = await delay.untilEvent(server, 'request');\n   * ```\n   */\n  untilEvent: (target: HasAddEventListener, eventName: string): Promise<Event> =>\n    new Promise((resolve) =>\n      target.addEventListener(eventName, resolve, { once: true, passive: true })\n    ),\n\n  /**\n   * Yields control to the event loop immediately.\n   *\n   * Uses `setImmediate` if available, falls back to `queueMicrotask`, and then to `setTimeout(0)`.\n   *\n   * @returns A Promise that resolves immediately after yielding control to the event loop.\n   *\n   * @example\n   * ```typescript\n   * await delay.immediate();\n   * ```\n   */\n  immediate: (): Promise<void> => {\n    if (typeof setImmediate !== 'function') {\n      if (typeof queueMicrotask === 'function') {\n        return delay.nextMicrotask();\n      }\n\n      // else\n      return delay.by(0);\n    }\n    return new Promise((resolve) => setImmediate(resolve));\n  },\n\n  /**\n   * Delays execution until the next microtask queue is empty\n   *\n   * @returns A Promise that resolves when the next microtask queue is empty.\n   *\n   * @example\n   * ```typescript\n   * await delay.nextMicrotask();\n   * ```\n   */\n  nextMicrotask: (): Promise<void> => {\n    if (typeof queueMicrotask !== 'function') {\n      if (typeof setImmediate === 'function') {\n        return delay.immediate();\n      }\n\n      // else\n      return delay.by(0);\n    }\n    return new Promise((resolve) => queueMicrotask(resolve));\n  },\n} as const;\n", "import {getGlobalThis, type GlobalThis} from '@alwatr/global-this';\n\nexport const win = /* #__PURE__ */ getGlobalThis<DictionaryOpt<unknown>>();\n\n// prettier-ignore\nconst requestAnimationFrameFallback =\n  (callback: FrameRequestCallback): ReturnType<typeof setTimeout> =>\n    setTimeout(() => callback(Date.now()), 1000 / 60);\n\nexport const requestAnimationFrame: GlobalThis['requestAnimationFrame'] = /* #__PURE__ */ (() =>\n  win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || requestAnimationFrameFallback)();\n\n// prettier-ignore\nconst requestIdleCallbackFallback =\n  (callback: () => void, options?: IdleRequestOptions): ReturnType<typeof setTimeout> =>\n    setTimeout(callback, options?.timeout ?? 2000);\n\nexport const requestIdleCallback: GlobalThis['requestIdleCallback'] = /* #__PURE__ */ (() =>\n  win.requestIdleCallback || win.webkitRequestIdleCallback || win.mozRequestIdleCallback || requestIdleCallbackFallback)();\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAA4B;AAC5B,4BAA2C;;;ACD3C,yBAA6C;AAEtC,IAAM,MAAsB,sDAAsC;AAGzE,IAAM,gCACJ,CAAC,aACC,WAAW,MAAM,SAAS,KAAK,IAAI,CAAC,GAAG,MAAO,EAAE;AAE7C,IAAM,wBAA8E,uBACzF,IAAI,yBAAyB,IAAI,+BAA+B,IAAI,4BAA4B,+BAA+B;AAGjI,IAAM,8BACJ,CAAC,UAAsB,YACrB,WAAW,UAAU,SAAS,WAAW,GAAI;AAE1C,IAAM,sBAA0E,uBACrF,IAAI,uBAAuB,IAAI,6BAA6B,IAAI,0BAA0B,6BAA6B;;;ADfzH,aAAc,qCAAc,IAAI,iBAAkB,QAAmB;AAO9D,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYnB,IAAI,CAAC,aACH,IAAI,QAAQ,CAAC,YAAY,WAAW,aAAS,qCAAc,QAAQ,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYvE,yBAAyB,MACvB,IAAI,QAAQ,CAAC,YAAY,sBAAsB,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAazD,WAAW,CAAC,YACV,IAAI,QAAQ,CAAC,YAAY,oBAAoB,SAAS,YAAY,SAAY,SAAY;AAAA,IACxF,aAAS,qCAAc,OAAO;AAAA,EAChC,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeJ,eAAe,CACb,SACA,cAEA,IAAI;AAAA,IAAQ,CAAC,YACX,QAAQ,iBAAiB,WAAW,SAAS,EAAE,MAAM,MAAM,SAAS,KAAK,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeF,YAAY,CAAC,QAA6B,cACxC,IAAI;AAAA,IAAQ,CAAC,YACX,OAAO,iBAAiB,WAAW,SAAS,EAAE,MAAM,MAAM,SAAS,KAAK,CAAC;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcF,WAAW,MAAqB;AAC9B,QAAI,OAAO,iBAAiB,YAAY;AACtC,UAAI,OAAO,mBAAmB,YAAY;AACxC,eAAO,MAAM,cAAc;AAAA,MAC7B;AAGA,aAAO,MAAM,GAAG,CAAC;AAAA,IACnB;AACA,WAAO,IAAI,QAAQ,CAAC,YAAY,aAAa,OAAO,CAAC;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,eAAe,MAAqB;AAClC,QAAI,OAAO,mBAAmB,YAAY;AACxC,UAAI,OAAO,iBAAiB,YAAY;AACtC,eAAO,MAAM,UAAU;AAAA,MACzB;AAGA,aAAO,MAAM,GAAG,CAAC;AAAA,IACnB;AACA,WAAO,IAAI,QAAQ,CAAC,YAAY,eAAe,OAAO,CAAC;AAAA,EACzD;AACF;",
+  "sourcesContent": ["import {packageTracer} from '@alwatr/package-tracer';\nimport {parseDuration, type Duration} from '@alwatr/parse-duration';\n\nimport {requestAnimationFrame, requestIdleCallback} from './polyfill.js';\n\nexport {requestAnimationFrame, requestIdleCallback};\n\n__dev_mode__: packageTracer.add(__package_name__, __package_version__);\n\n/**\n * A utility module to help manage asynchronous operations and waiting for events or timeouts.\n */\nexport const delay = {\n  /**\n   * Pauses execution for a specified duration.\n   *\n   * @param duration The duration to wait. Can be a number in milliseconds or a string like '2s', '100ms'.\n   * @returns A Promise that resolves after the specified duration.\n   *\n   * @example\n   * ```typescript\n   * await delay.by('1m'); // Wait for 1 minute\n   * await delay.by('2s'); // Wait for 2 seconds\n   * ```\n   */\n  by: (duration: Duration): Promise<void> => new Promise((resolve) => setTimeout(resolve, parseDuration(duration))),\n\n  /**\n   * Pauses execution until the next animation frame.\n   *\n   * @returns A Promise that resolves with the high-resolution timestamp of the next animation frame.\n   *\n   * @example\n   * ```typescript\n   * const timestamp = await delay.animationFrame();\n   * console.log(`Next frame at ${timestamp}`);\n   * ```\n   */\n  animationFrame: (): Promise<DOMHighResTimeStamp> => new Promise((resolve) => requestAnimationFrame(resolve)),\n\n  /**\n   * Pauses execution until the browser is idle.\n   *\n   * @param timeout An optional maximum duration to wait.\n   * @returns A Promise that resolves with an `IdleDeadline` object.\n   *\n   * @example\n   * ```typescript\n   * const deadline = await delay.idleCallback({ timeout: 2000 });\n   * if (deadline.didTimeout) {\n   * console.log('Idle callback timed out.');\n   * }\n   * ```\n   */\n  idleCallback: (options?: IdleRequestOptions): Promise<IdleDeadline> => new Promise((resolve) => requestIdleCallback(resolve, options)),\n\n  /**\n   * Pauses execution until a specific DOM event is dispatched on an element.\n   *\n   * @param element The HTMLElement to listen on.\n   * @param eventName The name of the event to wait for.\n   * @param options Optional event listener options.\n   * @template T The event map type for the element.\n   * @returns A Promise that resolves with the triggered event object.\n   *\n   * @example\n   * ```typescript\n   * const button = document.getElementById('my-button');\n   * if (button) {\n   * const clickEvent = await delay.domEvent(button, 'click');\n   * console.log('Button clicked!', clickEvent);\n   * }\n   * ```\n   */\n  domEvent: <T extends keyof HTMLElementEventMap>(\n    element: HTMLElement,\n    eventName: T,\n    options: AddEventListenerOptions = {passive: true},\n  ): Promise<HTMLElementEventMap[T]> =>\n    new Promise((resolve) =>\n      element.addEventListener(eventName, resolve, {\n        ...options,\n        once: true,\n      }),\n    ),\n\n  /**\n   * Pauses execution until a specific event is dispatched on any event target.\n   *\n   * @param target The event target (e.g., window, document, or a custom event emitter).\n   * @param eventName The name of the event to wait for.\n   * @param options Optional event listener options.\n   * @returns A Promise that resolves with the triggered event object.\n   *\n   * @example\n   * ```typescript\n   * const resizeEvent = await delay.event(window, 'resize');\n   * console.log('Window resized:', resizeEvent);\n   * ```\n   */\n  event: (target: EventTarget, eventName: string, options: AddEventListenerOptions = {passive: true}): Promise<Event> =>\n    new Promise((resolve) =>\n      target.addEventListener(eventName, resolve, {\n        ...options,\n        once: true,\n      }),\n    ),\n\n  /**\n   * Schedules a macrotask to run after the current event loop task completes.\n   * Uses `setTimeout(..., 0)`.\n   *\n   * @returns A Promise that resolves when the macrotask is executed.\n   *\n   * @example\n   * ```typescript\n   * console.log('Start');\n   * await delay.nextMacrotask();\n   * console.log('End - after current task');\n   * ```\n   */\n  nextMacrotask: (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0)),\n\n  /**\n   * Queues a microtask to run after the current task completes but before the next macrotask.\n   *\n   * @returns A Promise that resolves when the microtask is executed.\n   *\n   * @example\n   * ```typescript\n   * console.log('Start');\n   * await delay.nextMicrotask();\n   * console.log('End - immediately after current task');\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  nextMicrotask: (): Promise<void> => Promise.resolve().then(() => {}),\n} as const;\n", "import {getGlobalThis} from '@alwatr/global-this';\n\nconst globalThis = /* #__PURE__ */ getGlobalThis<DictionaryOpt<unknown>>();\n\n/**\n * Ensures compatibility for `requestAnimationFrame` by using the native API\n * available in `globalThis`. If it's not available, it falls back to a `setTimeout`\n * call that aims for a 60 frames per second refresh rate.\n *\n * @param callback The function to call when it's time to update your animation for the next repaint.\n * @returns A long integer value, the request ID, that uniquely identifies the entry in the callback list.\n */\nexport const requestAnimationFrame: (callback: FrameRequestCallback) => number =\n  /* #__PURE__ */ globalThis.requestAnimationFrame?.bind(globalThis) ??\n  /* #__PURE__ */ ((callback: FrameRequestCallback) => setTimeout(() => callback(performance.now()), 1000 / 60));\n\n/**\n * Ensures compatibility for `requestIdleCallback` by using the native API.\n * If unavailable, it falls back to a `setTimeout` that executes the callback\n * after a short delay, providing a mock `IdleDeadline` object.\n *\n * The mock `IdleDeadline` gives the task a 50ms budget to run.\n *\n * @param callback A reference to a function that should be called in the near future, when the event loop is idle.\n * @param options An optional object with configuration parameters.\n * @returns An ID which can be used to cancel the callback by calling `cancelIdleCallback()`.\n */\nexport const requestIdleCallback: (callback: (deadline: IdleDeadline) => void, options?: IdleRequestOptions) => number =\n  /* #__PURE__ */ globalThis.requestIdleCallback?.bind(globalThis) ??\n  /* #__PURE__ */ ((\n    callback: (deadline: IdleDeadline) => void,\n    // options is not used in the fallback but kept for API consistency\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    options?: IdleRequestOptions,\n  ) => {\n    const startTime = Date.now();\n    return setTimeout(() => {\n      callback({\n        didTimeout: !!options?.timeout,\n        timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime)),\n      });\n    }, options?.timeout ?? 20);\n  });\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAA4B;AAC5B,4BAA2C;;;ACD3C,yBAA4B;AAE5B,IAAM,aAA6B,sDAAsC;AAUlE,IAAM,wBACK,2BAAW,uBAAuB,KAAK,UAAU,MAChD,CAAC,aAAmC,WAAW,MAAM,SAAS,YAAY,IAAI,CAAC,GAAG,MAAO,EAAE;AAavG,IAAM,sBACK,2BAAW,qBAAqB,KAAK,UAAU,MAC9C,CACf,UAGA,YACG;AACH,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,WAAW,MAAM;AACtB,aAAS;AAAA,MACP,YAAY,CAAC,CAAC,SAAS;AAAA,MACvB,eAAe,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,IAAI,IAAI,UAAU;AAAA,IAChE,CAAC;AAAA,EACH,GAAG,SAAS,WAAW,EAAE;AAC3B;;;ADnCF,aAAc,qCAAc,IAAI,iBAAkB,OAAmB;AAK9D,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanB,IAAI,CAAC,aAAsC,IAAI,QAAQ,CAAC,YAAY,WAAW,aAAS,qCAAc,QAAQ,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAahH,gBAAgB,MAAoC,IAAI,QAAQ,CAAC,YAAY,sBAAsB,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgB3G,cAAc,CAAC,YAAwD,IAAI,QAAQ,CAAC,YAAY,oBAAoB,SAAS,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBrI,UAAU,CACR,SACA,WACA,UAAmC,EAAC,SAAS,KAAI,MAEjD,IAAI;AAAA,IAAQ,CAAC,YACX,QAAQ,iBAAiB,WAAW,SAAS;AAAA,MAC3C,GAAG;AAAA,MACH,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBF,OAAO,CAAC,QAAqB,WAAmB,UAAmC,EAAC,SAAS,KAAI,MAC/F,IAAI;AAAA,IAAQ,CAAC,YACX,OAAO,iBAAiB,WAAW,SAAS;AAAA,MAC1C,GAAG;AAAA,MACH,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeF,eAAe,MAAqB,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAenF,eAAe,MAAqB,QAAQ,QAAQ,EAAE,KAAK,MAAM;AAAA,EAAC,CAAC;AACrE;",
   "names": []
 }

package/dist/main.d.ts

@@ -1,92 +1,108 @@
 import { type Duration } from '@alwatr/parse-duration';
+import { requestAnimationFrame, requestIdleCallback } from './polyfill.js';
+export { requestAnimationFrame, requestIdleCallback };
 /**
  * A utility module to help manage asynchronous operations and waiting for events or timeouts.
  */
 export declare const delay: {
     /**
-     * Delays execution for a specified duration (in milliseconds).
+     * Pauses execution for a specified duration.
      *
-     * @param duration - The duration to wait (in milliseconds). Use `0` to yield control to the event loop.
+     * @param duration The duration to wait. Can be a number in milliseconds or a string like '2s', '100ms'.
      * @returns A Promise that resolves after the specified duration.
      *
      * @example
      * ```typescript
      * await delay.by('1m'); // Wait for 1 minute
+     * await delay.by('2s'); // Wait for 2 seconds
      * ```
      */
     readonly by: (duration: Duration) => Promise<void>;
     /**
-     * Delays execution until the next animation frame.
+     * Pauses execution until the next animation frame.
      *
-     * @returns A Promise that resolves with the current timestamp when the next animation frame is fired.
+     * @returns A Promise that resolves with the high-resolution timestamp of the next animation frame.
      *
      * @example
      * ```typescript
-     * const timestamp = await delay.untilNextAnimationFrame();
+     * const timestamp = await delay.animationFrame();
+     * console.log(`Next frame at ${timestamp}`);
      * ```
      */
-    readonly untilNextAnimationFrame: () => Promise<DOMHighResTimeStamp>;
+    readonly animationFrame: () => Promise<DOMHighResTimeStamp>;
     /**
-     * Delays execution until the browser's idle period or the specified timeout.
+     * Pauses execution until the browser is idle.
      *
-     * @param timeout - Optional timeout (in milliseconds) for the idle callback.
-     * @returns A Promise that resolves with the IdleDeadline object when the browser is idle or the timeout is reached.
+     * @param timeout An optional maximum duration to wait.
+     * @returns A Promise that resolves with an `IdleDeadline` object.
      *
      * @example
      * ```typescript
-     * const deadline = await delay.untilIdle();
+     * const deadline = await delay.idleCallback({ timeout: 2000 });
+     * if (deadline.didTimeout) {
+     * console.log('Idle callback timed out.');
+     * }
      * ```
      */
-    readonly untilIdle: (timeout?: Duration) => Promise<IdleDeadline>;
+    readonly idleCallback: (options?: IdleRequestOptions) => Promise<IdleDeadline>;
     /**
-     * Delays execution until a specific DOM event occurs on an HTMLElement.
+     * Pauses execution until a specific DOM event is dispatched on an element.
      *
-     * @param element - The HTMLElement to listen for the event on.
-     * @param eventName - The name of the DOM event to wait for.
-     * @template T The event map type.
-     * @returns A Promise that resolves with the event object when the specified event occurs.
+     * @param element The HTMLElement to listen on.
+     * @param eventName The name of the event to wait for.
+     * @param options Optional event listener options.
+     * @template T The event map type for the element.
+     * @returns A Promise that resolves with the triggered event object.
      *
      * @example
      * ```typescript
-     * const clickEvent = await delay.untilDomEvent(document.body, 'click');
+     * const button = document.getElementById('my-button');
+     * if (button) {
+     * const clickEvent = await delay.domEvent(button, 'click');
+     * console.log('Button clicked!', clickEvent);
+     * }
      * ```
      */
-    readonly untilDomEvent: <T extends keyof HTMLElementEventMap>(element: HTMLElement, eventName: T) => Promise<HTMLElementEventMap[T]>;
+    readonly domEvent: <T extends keyof HTMLElementEventMap>(element: HTMLElement, eventName: T, options?: AddEventListenerOptions) => Promise<HTMLElementEventMap[T]>;
     /**
-     * Delays execution until a specific event occurs on an object with an `addEventListener` method.
+     * Pauses execution until a specific event is dispatched on any event target.
      *
-     * @param target - The target object to listen for the event on.
-     * @param eventName - The name of the event to wait for.
-     * @returns A Promise that resolves with the event object when the specified event occurs.
+     * @param target The event target (e.g., window, document, or a custom event emitter).
+     * @param eventName The name of the event to wait for.
+     * @param options Optional event listener options.
+     * @returns A Promise that resolves with the triggered event object.
      *
      * @example
      * ```typescript
-     * const server = http.createServer();
-     * const requestEvent = await delay.untilEvent(server, 'request');
+     * const resizeEvent = await delay.event(window, 'resize');
+     * console.log('Window resized:', resizeEvent);
      * ```
      */
-    readonly untilEvent: (target: HasAddEventListener, eventName: string) => Promise<Event>;
+    readonly event: (target: EventTarget, eventName: string, options?: AddEventListenerOptions) => Promise<Event>;
     /**
-     * Yields control to the event loop immediately.
+     * Schedules a macrotask to run after the current event loop task completes.
+     * Uses `setTimeout(..., 0)`.
      *
-     * Uses `setImmediate` if available, falls back to `queueMicrotask`, and then to `setTimeout(0)`.
-     *
-     * @returns A Promise that resolves immediately after yielding control to the event loop.
+     * @returns A Promise that resolves when the macrotask is executed.
      *
      * @example
      * ```typescript
-     * await delay.immediate();
+     * console.log('Start');
+     * await delay.nextMacrotask();
+     * console.log('End - after current task');
      * ```
      */
-    readonly immediate: () => Promise<void>;
+    readonly nextMacrotask: () => Promise<void>;
     /**
-     * Delays execution until the next microtask queue is empty
+     * Queues a microtask to run after the current task completes but before the next macrotask.
      *
-     * @returns A Promise that resolves when the next microtask queue is empty.
+     * @returns A Promise that resolves when the microtask is executed.
      *
      * @example
      * ```typescript
+     * console.log('Start');
      * await delay.nextMicrotask();
+     * console.log('End - immediately after current task');
      * ```
      */
     readonly nextMicrotask: () => Promise<void>;

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,QAAQ,EAAC,MAAM,wBAAwB,CAAC;AAMpE;;GAEG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;;;;;OAUG;4BACY,QAAQ,KAAG,OAAO,CAAC,IAAI,CAAC;IAGvC;;;;;;;;;OASG;4CAC0B,OAAO,CAAC,mBAAmB,CAAC;IAGzD;;;;;;;;;;OAUG;mCACmB,QAAQ,KAAG,OAAO,CAAC,YAAY,CAAC;IAKtD;;;;;;;;;;;;OAYG;6BACa,CAAC,SAAS,MAAM,mBAAmB,WACxC,WAAW,aACT,CAAC,KACX,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAKlC;;;;;;;;;;;;OAYG;kCACkB,mBAAmB,aAAa,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC;IAK5E;;;;;;;;;;;OAWG;8BACY,OAAO,CAAC,IAAI,CAAC;IAY5B;;;;;;;;;OASG;kCACgB,OAAO,CAAC,IAAI,CAAC;CAWxB,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,QAAQ,EAAC,MAAM,wBAAwB,CAAC;AAEpE,OAAO,EAAC,qBAAqB,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAEzE,OAAO,EAAC,qBAAqB,EAAE,mBAAmB,EAAC,CAAC;AAIpD;;GAEG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;;;;;;OAWG;4BACY,QAAQ,KAAG,OAAO,CAAC,IAAI,CAAC;IAEvC;;;;;;;;;;OAUG;mCACiB,OAAO,CAAC,mBAAmB,CAAC;IAEhD;;;;;;;;;;;;;OAaG;sCACsB,kBAAkB,KAAG,OAAO,CAAC,YAAY,CAAC;IAEnE;;;;;;;;;;;;;;;;;OAiBG;wBACQ,CAAC,SAAS,MAAM,mBAAmB,WACnC,WAAW,aACT,CAAC,YACH,uBAAuB,KAC/B,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAQlC;;;;;;;;;;;;;OAaG;6BACa,WAAW,aAAa,MAAM,YAAW,uBAAuB,KAAqB,OAAO,CAAC,KAAK,CAAC;IAQnH;;;;;;;;;;;;OAYG;kCACgB,OAAO,CAAC,IAAI,CAAC;IAEhC;;;;;;;;;;;OAWG;kCAEgB,OAAO,CAAC,IAAI,CAAC;CACxB,CAAC"}

package/dist/main.mjs

@@ -1,4 +1,4 @@
-/* @alwatr/delay v5.5.11 */
+/* @alwatr/delay v6.0.0 */
 
 // src/main.ts
 import { packageTracer } from "@alwatr/package-tracer";
@@ -6,126 +6,138 @@ import { parseDuration } from "@alwatr/parse-duration";
 
 // src/polyfill.ts
 import { getGlobalThis } from "@alwatr/global-this";
-var win = /* @__PURE__ */ getGlobalThis();
-var requestAnimationFrameFallback = (callback) => setTimeout(() => callback(Date.now()), 1e3 / 60);
-var requestAnimationFrame = /* @__PURE__ */ (() => win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || requestAnimationFrameFallback)();
-var requestIdleCallbackFallback = (callback, options) => setTimeout(callback, options?.timeout ?? 2e3);
-var requestIdleCallback = /* @__PURE__ */ (() => win.requestIdleCallback || win.webkitRequestIdleCallback || win.mozRequestIdleCallback || requestIdleCallbackFallback)();
+var globalThis = /* @__PURE__ */ getGlobalThis();
+var requestAnimationFrame = /* @__PURE__ */ globalThis.requestAnimationFrame?.bind(globalThis) ?? ((callback) => setTimeout(() => callback(performance.now()), 1e3 / 60));
+var requestIdleCallback = /* @__PURE__ */ globalThis.requestIdleCallback?.bind(globalThis) ?? ((callback, options) => {
+  const startTime = Date.now();
+  return setTimeout(() => {
+    callback({
+      didTimeout: !!options?.timeout,
+      timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime))
+    });
+  }, options?.timeout ?? 20);
+});
 
 // src/main.ts
-__dev_mode__: packageTracer.add("@alwatr/delay", "5.5.11");
+__dev_mode__: packageTracer.add("@alwatr/delay", "6.0.0");
 var delay = {
   /**
-   * Delays execution for a specified duration (in milliseconds).
+   * Pauses execution for a specified duration.
    *
-   * @param duration - The duration to wait (in milliseconds). Use `0` to yield control to the event loop.
+   * @param duration The duration to wait. Can be a number in milliseconds or a string like '2s', '100ms'.
    * @returns A Promise that resolves after the specified duration.
    *
    * @example
    * ```typescript
    * await delay.by('1m'); // Wait for 1 minute
+   * await delay.by('2s'); // Wait for 2 seconds
    * ```
    */
   by: (duration) => new Promise((resolve) => setTimeout(resolve, parseDuration(duration))),
   /**
-   * Delays execution until the next animation frame.
+   * Pauses execution until the next animation frame.
    *
-   * @returns A Promise that resolves with the current timestamp when the next animation frame is fired.
+   * @returns A Promise that resolves with the high-resolution timestamp of the next animation frame.
    *
    * @example
    * ```typescript
-   * const timestamp = await delay.untilNextAnimationFrame();
+   * const timestamp = await delay.animationFrame();
+   * console.log(`Next frame at ${timestamp}`);
    * ```
    */
-  untilNextAnimationFrame: () => new Promise((resolve) => requestAnimationFrame(resolve)),
+  animationFrame: () => new Promise((resolve) => requestAnimationFrame(resolve)),
   /**
-   * Delays execution until the browser's idle period or the specified timeout.
+   * Pauses execution until the browser is idle.
    *
-   * @param timeout - Optional timeout (in milliseconds) for the idle callback.
-   * @returns A Promise that resolves with the IdleDeadline object when the browser is idle or the timeout is reached.
+   * @param timeout An optional maximum duration to wait.
+   * @returns A Promise that resolves with an `IdleDeadline` object.
    *
    * @example
    * ```typescript
-   * const deadline = await delay.untilIdle();
+   * const deadline = await delay.idleCallback({ timeout: 2000 });
+   * if (deadline.didTimeout) {
+   * console.log('Idle callback timed out.');
+   * }
    * ```
    */
-  untilIdle: (timeout) => new Promise((resolve) => requestIdleCallback(resolve, timeout === void 0 ? void 0 : {
-    timeout: parseDuration(timeout)
-  })),
+  idleCallback: (options) => new Promise((resolve) => requestIdleCallback(resolve, options)),
   /**
-   * Delays execution until a specific DOM event occurs on an HTMLElement.
+   * Pauses execution until a specific DOM event is dispatched on an element.
    *
-   * @param element - The HTMLElement to listen for the event on.
-   * @param eventName - The name of the DOM event to wait for.
-   * @template T The event map type.
-   * @returns A Promise that resolves with the event object when the specified event occurs.
+   * @param element The HTMLElement to listen on.
+   * @param eventName The name of the event to wait for.
+   * @param options Optional event listener options.
+   * @template T The event map type for the element.
+   * @returns A Promise that resolves with the triggered event object.
    *
    * @example
    * ```typescript
-   * const clickEvent = await delay.untilDomEvent(document.body, 'click');
+   * const button = document.getElementById('my-button');
+   * if (button) {
+   * const clickEvent = await delay.domEvent(button, 'click');
+   * console.log('Button clicked!', clickEvent);
+   * }
    * ```
    */
-  untilDomEvent: (element, eventName) => new Promise(
-    (resolve) => element.addEventListener(eventName, resolve, { once: true, passive: true })
+  domEvent: (element, eventName, options = { passive: true }) => new Promise(
+    (resolve) => element.addEventListener(eventName, resolve, {
+      ...options,
+      once: true
+    })
   ),
   /**
-   * Delays execution until a specific event occurs on an object with an `addEventListener` method.
+   * Pauses execution until a specific event is dispatched on any event target.
    *
-   * @param target - The target object to listen for the event on.
-   * @param eventName - The name of the event to wait for.
-   * @returns A Promise that resolves with the event object when the specified event occurs.
+   * @param target The event target (e.g., window, document, or a custom event emitter).
+   * @param eventName The name of the event to wait for.
+   * @param options Optional event listener options.
+   * @returns A Promise that resolves with the triggered event object.
    *
    * @example
    * ```typescript
-   * const server = http.createServer();
-   * const requestEvent = await delay.untilEvent(server, 'request');
+   * const resizeEvent = await delay.event(window, 'resize');
+   * console.log('Window resized:', resizeEvent);
    * ```
    */
-  untilEvent: (target, eventName) => new Promise(
-    (resolve) => target.addEventListener(eventName, resolve, { once: true, passive: true })
+  event: (target, eventName, options = { passive: true }) => new Promise(
+    (resolve) => target.addEventListener(eventName, resolve, {
+      ...options,
+      once: true
+    })
   ),
   /**
-   * Yields control to the event loop immediately.
+   * Schedules a macrotask to run after the current event loop task completes.
+   * Uses `setTimeout(..., 0)`.
    *
-   * Uses `setImmediate` if available, falls back to `queueMicrotask`, and then to `setTimeout(0)`.
-   *
-   * @returns A Promise that resolves immediately after yielding control to the event loop.
+   * @returns A Promise that resolves when the macrotask is executed.
    *
    * @example
    * ```typescript
-   * await delay.immediate();
+   * console.log('Start');
+   * await delay.nextMacrotask();
+   * console.log('End - after current task');
    * ```
    */
-  immediate: () => {
-    if (typeof setImmediate !== "function") {
-      if (typeof queueMicrotask === "function") {
-        return delay.nextMicrotask();
-      }
-      return delay.by(0);
-    }
-    return new Promise((resolve) => setImmediate(resolve));
-  },
+  nextMacrotask: () => new Promise((resolve) => setTimeout(resolve, 0)),
   /**
-   * Delays execution until the next microtask queue is empty
+   * Queues a microtask to run after the current task completes but before the next macrotask.
    *
-   * @returns A Promise that resolves when the next microtask queue is empty.
+   * @returns A Promise that resolves when the microtask is executed.
    *
    * @example
    * ```typescript
+   * console.log('Start');
    * await delay.nextMicrotask();
+   * console.log('End - immediately after current task');
    * ```
    */
-  nextMicrotask: () => {
-    if (typeof queueMicrotask !== "function") {
-      if (typeof setImmediate === "function") {
-        return delay.immediate();
-      }
-      return delay.by(0);
-    }
-    return new Promise((resolve) => queueMicrotask(resolve));
-  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  nextMicrotask: () => Promise.resolve().then(() => {
+  })
 };
 export {
-  delay
+  delay,
+  requestAnimationFrame,
+  requestIdleCallback
 };
 //# sourceMappingURL=main.mjs.map

package/dist/main.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/main.ts", "../src/polyfill.ts"],
-  "sourcesContent": ["import {packageTracer} from '@alwatr/package-tracer';\nimport {parseDuration, type Duration} from '@alwatr/parse-duration';\n\n__dev_mode__: packageTracer.add(__package_name__, __package_version__);\n\nimport {requestAnimationFrame, requestIdleCallback} from './polyfill.js';\n\n/**\n * A utility module to help manage asynchronous operations and waiting for events or timeouts.\n */\nexport const delay = {\n  /**\n   * Delays execution for a specified duration (in milliseconds).\n   *\n   * @param duration - The duration to wait (in milliseconds). Use `0` to yield control to the event loop.\n   * @returns A Promise that resolves after the specified duration.\n   *\n   * @example\n   * ```typescript\n   * await delay.by('1m'); // Wait for 1 minute\n   * ```\n   */\n  by: (duration: Duration): Promise<void> =>\n    new Promise((resolve) => setTimeout(resolve, parseDuration(duration))),\n\n  /**\n   * Delays execution until the next animation frame.\n   *\n   * @returns A Promise that resolves with the current timestamp when the next animation frame is fired.\n   *\n   * @example\n   * ```typescript\n   * const timestamp = await delay.untilNextAnimationFrame();\n   * ```\n   */\n  untilNextAnimationFrame: (): Promise<DOMHighResTimeStamp> =>\n    new Promise((resolve) => requestAnimationFrame(resolve)),\n\n  /**\n   * Delays execution until the browser's idle period or the specified timeout.\n   *\n   * @param timeout - Optional timeout (in milliseconds) for the idle callback.\n   * @returns A Promise that resolves with the IdleDeadline object when the browser is idle or the timeout is reached.\n   *\n   * @example\n   * ```typescript\n   * const deadline = await delay.untilIdle();\n   * ```\n   */\n  untilIdle: (timeout?: Duration): Promise<IdleDeadline> =>\n    new Promise((resolve) => requestIdleCallback(resolve, timeout === undefined ? undefined : {\n      timeout: parseDuration(timeout)\n    })),\n\n  /**\n   * Delays execution until a specific DOM event occurs on an HTMLElement.\n   *\n   * @param element - The HTMLElement to listen for the event on.\n   * @param eventName - The name of the DOM event to wait for.\n   * @template T The event map type.\n   * @returns A Promise that resolves with the event object when the specified event occurs.\n   *\n   * @example\n   * ```typescript\n   * const clickEvent = await delay.untilDomEvent(document.body, 'click');\n   * ```\n   */\n  untilDomEvent: <T extends keyof HTMLElementEventMap>(\n    element: HTMLElement,\n    eventName: T\n  ): Promise<HTMLElementEventMap[T]> =>\n    new Promise((resolve) =>\n      element.addEventListener(eventName, resolve, { once: true, passive: true })\n    ),\n\n  /**\n   * Delays execution until a specific event occurs on an object with an `addEventListener` method.\n   *\n   * @param target - The target object to listen for the event on.\n   * @param eventName - The name of the event to wait for.\n   * @returns A Promise that resolves with the event object when the specified event occurs.\n   *\n   * @example\n   * ```typescript\n   * const server = http.createServer();\n   * const requestEvent = await delay.untilEvent(server, 'request');\n   * ```\n   */\n  untilEvent: (target: HasAddEventListener, eventName: string): Promise<Event> =>\n    new Promise((resolve) =>\n      target.addEventListener(eventName, resolve, { once: true, passive: true })\n    ),\n\n  /**\n   * Yields control to the event loop immediately.\n   *\n   * Uses `setImmediate` if available, falls back to `queueMicrotask`, and then to `setTimeout(0)`.\n   *\n   * @returns A Promise that resolves immediately after yielding control to the event loop.\n   *\n   * @example\n   * ```typescript\n   * await delay.immediate();\n   * ```\n   */\n  immediate: (): Promise<void> => {\n    if (typeof setImmediate !== 'function') {\n      if (typeof queueMicrotask === 'function') {\n        return delay.nextMicrotask();\n      }\n\n      // else\n      return delay.by(0);\n    }\n    return new Promise((resolve) => setImmediate(resolve));\n  },\n\n  /**\n   * Delays execution until the next microtask queue is empty\n   *\n   * @returns A Promise that resolves when the next microtask queue is empty.\n   *\n   * @example\n   * ```typescript\n   * await delay.nextMicrotask();\n   * ```\n   */\n  nextMicrotask: (): Promise<void> => {\n    if (typeof queueMicrotask !== 'function') {\n      if (typeof setImmediate === 'function') {\n        return delay.immediate();\n      }\n\n      // else\n      return delay.by(0);\n    }\n    return new Promise((resolve) => queueMicrotask(resolve));\n  },\n} as const;\n", "import {getGlobalThis, type GlobalThis} from '@alwatr/global-this';\n\nexport const win = /* #__PURE__ */ getGlobalThis<DictionaryOpt<unknown>>();\n\n// prettier-ignore\nconst requestAnimationFrameFallback =\n  (callback: FrameRequestCallback): ReturnType<typeof setTimeout> =>\n    setTimeout(() => callback(Date.now()), 1000 / 60);\n\nexport const requestAnimationFrame: GlobalThis['requestAnimationFrame'] = /* #__PURE__ */ (() =>\n  win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || requestAnimationFrameFallback)();\n\n// prettier-ignore\nconst requestIdleCallbackFallback =\n  (callback: () => void, options?: IdleRequestOptions): ReturnType<typeof setTimeout> =>\n    setTimeout(callback, options?.timeout ?? 2000);\n\nexport const requestIdleCallback: GlobalThis['requestIdleCallback'] = /* #__PURE__ */ (() =>\n  win.requestIdleCallback || win.webkitRequestIdleCallback || win.mozRequestIdleCallback || requestIdleCallbackFallback)();\n"],
-  "mappings": ";;;AAAA,SAAQ,qBAAoB;AAC5B,SAAQ,qBAAmC;;;ACD3C,SAAQ,qBAAqC;AAEtC,IAAM,MAAsB,8BAAsC;AAGzE,IAAM,gCACJ,CAAC,aACC,WAAW,MAAM,SAAS,KAAK,IAAI,CAAC,GAAG,MAAO,EAAE;AAE7C,IAAM,wBAA8E,uBACzF,IAAI,yBAAyB,IAAI,+BAA+B,IAAI,4BAA4B,+BAA+B;AAGjI,IAAM,8BACJ,CAAC,UAAsB,YACrB,WAAW,UAAU,SAAS,WAAW,GAAI;AAE1C,IAAM,sBAA0E,uBACrF,IAAI,uBAAuB,IAAI,6BAA6B,IAAI,0BAA0B,6BAA6B;;;ADfzH,aAAc,eAAc,IAAI,iBAAkB,QAAmB;AAO9D,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYnB,IAAI,CAAC,aACH,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,cAAc,QAAQ,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYvE,yBAAyB,MACvB,IAAI,QAAQ,CAAC,YAAY,sBAAsB,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAazD,WAAW,CAAC,YACV,IAAI,QAAQ,CAAC,YAAY,oBAAoB,SAAS,YAAY,SAAY,SAAY;AAAA,IACxF,SAAS,cAAc,OAAO;AAAA,EAChC,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeJ,eAAe,CACb,SACA,cAEA,IAAI;AAAA,IAAQ,CAAC,YACX,QAAQ,iBAAiB,WAAW,SAAS,EAAE,MAAM,MAAM,SAAS,KAAK,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeF,YAAY,CAAC,QAA6B,cACxC,IAAI;AAAA,IAAQ,CAAC,YACX,OAAO,iBAAiB,WAAW,SAAS,EAAE,MAAM,MAAM,SAAS,KAAK,CAAC;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcF,WAAW,MAAqB;AAC9B,QAAI,OAAO,iBAAiB,YAAY;AACtC,UAAI,OAAO,mBAAmB,YAAY;AACxC,eAAO,MAAM,cAAc;AAAA,MAC7B;AAGA,aAAO,MAAM,GAAG,CAAC;AAAA,IACnB;AACA,WAAO,IAAI,QAAQ,CAAC,YAAY,aAAa,OAAO,CAAC;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,eAAe,MAAqB;AAClC,QAAI,OAAO,mBAAmB,YAAY;AACxC,UAAI,OAAO,iBAAiB,YAAY;AACtC,eAAO,MAAM,UAAU;AAAA,MACzB;AAGA,aAAO,MAAM,GAAG,CAAC;AAAA,IACnB;AACA,WAAO,IAAI,QAAQ,CAAC,YAAY,eAAe,OAAO,CAAC;AAAA,EACzD;AACF;",
+  "sourcesContent": ["import {packageTracer} from '@alwatr/package-tracer';\nimport {parseDuration, type Duration} from '@alwatr/parse-duration';\n\nimport {requestAnimationFrame, requestIdleCallback} from './polyfill.js';\n\nexport {requestAnimationFrame, requestIdleCallback};\n\n__dev_mode__: packageTracer.add(__package_name__, __package_version__);\n\n/**\n * A utility module to help manage asynchronous operations and waiting for events or timeouts.\n */\nexport const delay = {\n  /**\n   * Pauses execution for a specified duration.\n   *\n   * @param duration The duration to wait. Can be a number in milliseconds or a string like '2s', '100ms'.\n   * @returns A Promise that resolves after the specified duration.\n   *\n   * @example\n   * ```typescript\n   * await delay.by('1m'); // Wait for 1 minute\n   * await delay.by('2s'); // Wait for 2 seconds\n   * ```\n   */\n  by: (duration: Duration): Promise<void> => new Promise((resolve) => setTimeout(resolve, parseDuration(duration))),\n\n  /**\n   * Pauses execution until the next animation frame.\n   *\n   * @returns A Promise that resolves with the high-resolution timestamp of the next animation frame.\n   *\n   * @example\n   * ```typescript\n   * const timestamp = await delay.animationFrame();\n   * console.log(`Next frame at ${timestamp}`);\n   * ```\n   */\n  animationFrame: (): Promise<DOMHighResTimeStamp> => new Promise((resolve) => requestAnimationFrame(resolve)),\n\n  /**\n   * Pauses execution until the browser is idle.\n   *\n   * @param timeout An optional maximum duration to wait.\n   * @returns A Promise that resolves with an `IdleDeadline` object.\n   *\n   * @example\n   * ```typescript\n   * const deadline = await delay.idleCallback({ timeout: 2000 });\n   * if (deadline.didTimeout) {\n   * console.log('Idle callback timed out.');\n   * }\n   * ```\n   */\n  idleCallback: (options?: IdleRequestOptions): Promise<IdleDeadline> => new Promise((resolve) => requestIdleCallback(resolve, options)),\n\n  /**\n   * Pauses execution until a specific DOM event is dispatched on an element.\n   *\n   * @param element The HTMLElement to listen on.\n   * @param eventName The name of the event to wait for.\n   * @param options Optional event listener options.\n   * @template T The event map type for the element.\n   * @returns A Promise that resolves with the triggered event object.\n   *\n   * @example\n   * ```typescript\n   * const button = document.getElementById('my-button');\n   * if (button) {\n   * const clickEvent = await delay.domEvent(button, 'click');\n   * console.log('Button clicked!', clickEvent);\n   * }\n   * ```\n   */\n  domEvent: <T extends keyof HTMLElementEventMap>(\n    element: HTMLElement,\n    eventName: T,\n    options: AddEventListenerOptions = {passive: true},\n  ): Promise<HTMLElementEventMap[T]> =>\n    new Promise((resolve) =>\n      element.addEventListener(eventName, resolve, {\n        ...options,\n        once: true,\n      }),\n    ),\n\n  /**\n   * Pauses execution until a specific event is dispatched on any event target.\n   *\n   * @param target The event target (e.g., window, document, or a custom event emitter).\n   * @param eventName The name of the event to wait for.\n   * @param options Optional event listener options.\n   * @returns A Promise that resolves with the triggered event object.\n   *\n   * @example\n   * ```typescript\n   * const resizeEvent = await delay.event(window, 'resize');\n   * console.log('Window resized:', resizeEvent);\n   * ```\n   */\n  event: (target: EventTarget, eventName: string, options: AddEventListenerOptions = {passive: true}): Promise<Event> =>\n    new Promise((resolve) =>\n      target.addEventListener(eventName, resolve, {\n        ...options,\n        once: true,\n      }),\n    ),\n\n  /**\n   * Schedules a macrotask to run after the current event loop task completes.\n   * Uses `setTimeout(..., 0)`.\n   *\n   * @returns A Promise that resolves when the macrotask is executed.\n   *\n   * @example\n   * ```typescript\n   * console.log('Start');\n   * await delay.nextMacrotask();\n   * console.log('End - after current task');\n   * ```\n   */\n  nextMacrotask: (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0)),\n\n  /**\n   * Queues a microtask to run after the current task completes but before the next macrotask.\n   *\n   * @returns A Promise that resolves when the microtask is executed.\n   *\n   * @example\n   * ```typescript\n   * console.log('Start');\n   * await delay.nextMicrotask();\n   * console.log('End - immediately after current task');\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  nextMicrotask: (): Promise<void> => Promise.resolve().then(() => {}),\n} as const;\n", "import {getGlobalThis} from '@alwatr/global-this';\n\nconst globalThis = /* #__PURE__ */ getGlobalThis<DictionaryOpt<unknown>>();\n\n/**\n * Ensures compatibility for `requestAnimationFrame` by using the native API\n * available in `globalThis`. If it's not available, it falls back to a `setTimeout`\n * call that aims for a 60 frames per second refresh rate.\n *\n * @param callback The function to call when it's time to update your animation for the next repaint.\n * @returns A long integer value, the request ID, that uniquely identifies the entry in the callback list.\n */\nexport const requestAnimationFrame: (callback: FrameRequestCallback) => number =\n  /* #__PURE__ */ globalThis.requestAnimationFrame?.bind(globalThis) ??\n  /* #__PURE__ */ ((callback: FrameRequestCallback) => setTimeout(() => callback(performance.now()), 1000 / 60));\n\n/**\n * Ensures compatibility for `requestIdleCallback` by using the native API.\n * If unavailable, it falls back to a `setTimeout` that executes the callback\n * after a short delay, providing a mock `IdleDeadline` object.\n *\n * The mock `IdleDeadline` gives the task a 50ms budget to run.\n *\n * @param callback A reference to a function that should be called in the near future, when the event loop is idle.\n * @param options An optional object with configuration parameters.\n * @returns An ID which can be used to cancel the callback by calling `cancelIdleCallback()`.\n */\nexport const requestIdleCallback: (callback: (deadline: IdleDeadline) => void, options?: IdleRequestOptions) => number =\n  /* #__PURE__ */ globalThis.requestIdleCallback?.bind(globalThis) ??\n  /* #__PURE__ */ ((\n    callback: (deadline: IdleDeadline) => void,\n    // options is not used in the fallback but kept for API consistency\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    options?: IdleRequestOptions,\n  ) => {\n    const startTime = Date.now();\n    return setTimeout(() => {\n      callback({\n        didTimeout: !!options?.timeout,\n        timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime)),\n      });\n    }, options?.timeout ?? 20);\n  });\n"],
+  "mappings": ";;;AAAA,SAAQ,qBAAoB;AAC5B,SAAQ,qBAAmC;;;ACD3C,SAAQ,qBAAoB;AAE5B,IAAM,aAA6B,8BAAsC;AAUlE,IAAM,wBACK,2BAAW,uBAAuB,KAAK,UAAU,MAChD,CAAC,aAAmC,WAAW,MAAM,SAAS,YAAY,IAAI,CAAC,GAAG,MAAO,EAAE;AAavG,IAAM,sBACK,2BAAW,qBAAqB,KAAK,UAAU,MAC9C,CACf,UAGA,YACG;AACH,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,WAAW,MAAM;AACtB,aAAS;AAAA,MACP,YAAY,CAAC,CAAC,SAAS;AAAA,MACvB,eAAe,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,IAAI,IAAI,UAAU;AAAA,IAChE,CAAC;AAAA,EACH,GAAG,SAAS,WAAW,EAAE;AAC3B;;;ADnCF,aAAc,eAAc,IAAI,iBAAkB,OAAmB;AAK9D,IAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanB,IAAI,CAAC,aAAsC,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,cAAc,QAAQ,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAahH,gBAAgB,MAAoC,IAAI,QAAQ,CAAC,YAAY,sBAAsB,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgB3G,cAAc,CAAC,YAAwD,IAAI,QAAQ,CAAC,YAAY,oBAAoB,SAAS,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBrI,UAAU,CACR,SACA,WACA,UAAmC,EAAC,SAAS,KAAI,MAEjD,IAAI;AAAA,IAAQ,CAAC,YACX,QAAQ,iBAAiB,WAAW,SAAS;AAAA,MAC3C,GAAG;AAAA,MACH,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBF,OAAO,CAAC,QAAqB,WAAmB,UAAmC,EAAC,SAAS,KAAI,MAC/F,IAAI;AAAA,IAAQ,CAAC,YACX,OAAO,iBAAiB,WAAW,SAAS;AAAA,MAC1C,GAAG;AAAA,MACH,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeF,eAAe,MAAqB,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAenF,eAAe,MAAqB,QAAQ,QAAQ,EAAE,KAAK,MAAM;AAAA,EAAC,CAAC;AACrE;",
   "names": []
 }

package/dist/polyfill.d.ts

@@ -1,5 +1,22 @@
-import { type GlobalThis } from '@alwatr/global-this';
-export declare const win: typeof globalThis & DictionaryOpt<unknown>;
-export declare const requestAnimationFrame: GlobalThis['requestAnimationFrame'];
-export declare const requestIdleCallback: GlobalThis['requestIdleCallback'];
+/**
+ * Ensures compatibility for `requestAnimationFrame` by using the native API
+ * available in `globalThis`. If it's not available, it falls back to a `setTimeout`
+ * call that aims for a 60 frames per second refresh rate.
+ *
+ * @param callback The function to call when it's time to update your animation for the next repaint.
+ * @returns A long integer value, the request ID, that uniquely identifies the entry in the callback list.
+ */
+export declare const requestAnimationFrame: (callback: FrameRequestCallback) => number;
+/**
+ * Ensures compatibility for `requestIdleCallback` by using the native API.
+ * If unavailable, it falls back to a `setTimeout` that executes the callback
+ * after a short delay, providing a mock `IdleDeadline` object.
+ *
+ * The mock `IdleDeadline` gives the task a 50ms budget to run.
+ *
+ * @param callback A reference to a function that should be called in the near future, when the event loop is idle.
+ * @param options An optional object with configuration parameters.
+ * @returns An ID which can be used to cancel the callback by calling `cancelIdleCallback()`.
+ */
+export declare const requestIdleCallback: (callback: (deadline: IdleDeadline) => void, options?: IdleRequestOptions) => number;
 //# sourceMappingURL=polyfill.d.ts.map

package/dist/polyfill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../src/polyfill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAEnE,eAAO,MAAM,GAAG,4CAA0D,CAAC;AAO3E,eAAO,MAAM,qBAAqB,EAAE,UAAU,CAAC,uBAAuB,CAC4D,CAAC;AAOnI,eAAO,MAAM,mBAAmB,EAAE,UAAU,CAAC,qBAAqB,CACwD,CAAC"}
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../src/polyfill.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAEwC,CAAC;AAEjH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,kBAAkB,KAAK,MAe5G,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alwatr/delay",
   "description": "Comprehensive toolkit for managing asynchronous operations.",
-  "version": "5.5.11",
+  "version": "6.0.0",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com>",
   "bugs": "https://github.com/Alwatr/nanolib/issues",
   "dependencies": {
@@ -77,5 +77,5 @@
   },
   "type": "module",
   "types": "./dist/main.d.ts",
-  "gitHead": "990a248963c89c4db8526dfaf6a24c1e2099a92e"
+  "gitHead": "5d7482af60778578d7adedf6b89a9f938e6cd776"
 }