@hyperfrontend/time-utils 0.0.4 → 1.0.0

package/CHANGELOG.md

@@ -1,16 +1,30 @@
 # Changelog
 
-This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+All notable changes to this project will be documented in this file.
 
-## [0.0.4](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.3...lib-time-utils@0.0.4) (2026-03-08)
+## [1.0.0](https://github.com/AndrewRedican/hyperfrontend/compare/5f116abb8ba6355dfb283fa03b7481e5eb029480...4b34883aead4c721f021465b19fa5bdd49514d37) - 2026-08-31
 
-## [0.0.3](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.2...lib-time-utils@0.0.3) (2026-03-02)
+### Features
 
+- Marked stable. No API changes since 0.0.5.
+
+## [0.0.5](https://github.com/AndrewRedican/hyperfrontend/compare/c8db08be8b183addd26caf81fdd17fb3693f296f...466c0388c4cd516b9c704214140b4df1004098e6) - 2026-06-23
+
+### Other
+
+- **@hyperfrontend/workspace:** remove lib-builder and tool-package as implicit dependencies for all lib projects
+
+## [0.0.4](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.3...lib-time-utils@0.0.4) - 2026-03-08
+
+
+## [0.0.3](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.2...lib-time-utils@0.0.3) - 2026-03-02
 
 ### Bug Fixes
 
-* **lib-time-utils:** correct package exports and dependencies ([3b9096b](https://github.com/AndrewRedican/hyperfrontend/commit/3b9096b54337c2c2f3e06d6b97865a772e79aad9))
+- **lib-time-utils:** correct package exports and dependencies ([3b9096b](https://github.com/AndrewRedican/hyperfrontend/commit/3b9096b54337c2c2f3e06d6b97865a772e79aad9))
+
+## [0.0.2](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.1...lib-time-utils@0.0.2) - 2026-02-26
+
 
-## [0.0.2](https://github.com/AndrewRedican/hyperfrontend/compare/lib-time-utils@0.0.1...lib-time-utils@0.0.2) (2026-02-26)
+## 0.0.1 - 2026-02-15
 
-## 0.0.1 (2026-02-15)

package/README.md

@@ -35,6 +35,9 @@
 
 Functional time utilities for async operations, intervals, and time normalization.
 
+• 👉 See [**documentation**](https://www.hyperfrontend.dev/docs/libraries/utils/time/)
+• 👉 See [**guides & tutorials**](https://www.hyperfrontend.dev/docs/guides/?package=%40hyperfrontend%2Ftime-utils)
+
 ## What is @hyperfrontend/time-utils?
 
 `@hyperfrontend/time-utils` provides composable, testable utilities for working with time-based operations in JavaScript. The library focuses on enhancing the control and flexibility of standard timing APIs (`setTimeout`, `setInterval`) while adding specialized utilities for async workflows and time window calculations.
@@ -60,7 +63,7 @@ All timing abstractions maintain internal state privately while exposing frozen
 
 ### 1. Pause/Resume Capabilities Native APIs Lack
 
-JavaScript's `setTimeout` and `setInterval` cannot be paused—once started, they either complete or get cancelled. This creates problems for features like user-initiated pauses in games, animations during background tabs, or request throttling. `createTimer()` tracks elapsed time internally, enabling pause/resume without restarting from the beginning or losing progress.
+JavaScript's `setTimeout` and `setInterval` cannot be paused: once started, they either complete or get cancelled. This creates problems for features like user-initiated pauses in games, animations during background tabs, or request throttling. `createTimer()` tracks elapsed time internally, enabling pause/resume without restarting from the beginning or losing progress.
 
 **Example:** A countdown timer in a game needs to pause when the user switches tabs. With `setTimeout`, you'd need to calculate remaining time manually and create a new timeout. With `createTimer`, just call `timer.pause()`.
 
@@ -245,7 +248,7 @@ cleanup()
 
 ### Dependencies
 
-None — zero external dependencies.
+None: zero external dependencies.
 
 ## Part of hyperfrontend
 
@@ -257,4 +260,4 @@ This library is part of the [hyperfrontend](https://github.com/AndrewRedican/hyp
 
 ## License
 
-MIT
+[MIT](https://github.com/AndrewRedican/hyperfrontend/blob/main/LICENSE.md)

package/SECURITY.md

@@ -1,5 +1,28 @@
 # Security Policy
 
+## The Security Model
+
+Before reporting or reviewing, read the model this project is built on:
+**[Security Model](https://www.hyperfrontend.dev/docs/core-concepts/security)**. It is the canonical
+statement of what hyperfrontend defends against and what it does not, and it is the reference every
+other security claim in these docs points back to. In short:
+
+- **The named adversary is co-resident script**: an analytics snippet, tag manager, compromised
+  dependency, or unknown page that embeds a feature URL. A host that deliberately installs a feature
+  is trusting it, the way it trusts any dependency; the controls exist to bound a trusted
+  feature's bad day, not to treat its authors as hostile.
+- **Origin checks authenticate rooms, not speakers.** Once arbitrary script runs inside a page, no
+  message check distinguishes it from the application. Threats inside a page need Content Security
+  Policy, Trusted Types, dependency provenance, and server-side authorisation. That is a different
+  treatment, deliberately outside this model.
+- **Three parties carry the security of an integration.** The browser enforces document isolation
+  and the frame's capability attributes; the protocol enforces the relationship (pinned
+  counterparts, gated handshake, validated payloads, versioned contracts, an optional encrypted
+  envelope); and **you** decide authorisation: `frame-ancestors`, backend checks, HTTPS, the
+  envelope you choose, and the containment posture you set.
+
+A vulnerability report is most useful when it names which of those three the issue defeats.
+
 ## Reporting a Vulnerability
 
 We take the security of hyperfrontend seriously. If you discover a security vulnerability, please help us protect our users by following responsible disclosure practices.
@@ -58,14 +81,30 @@ Thank you for helping keep hyperfrontend and its users safe!
 
 ## Security Best Practices
 
-When using hyperfrontend in your applications:
-
-1. **Keep Dependencies Updated**: Regularly update to the latest version to receive security patches
-2. **Content Security Policy**: Implement appropriate CSP headers when embedding features
-3. **Input Validation**: Validate and sanitize all data passed between features
-4. **Origin Verification**: Always verify the origin of messages in cross-frame communication
-5. **Authentication**: Implement proper authentication and authorization for sensitive features
-6. **HTTPS**: Always serve hyperfrontend features over HTTPS in production
+These are the decisions the SDK cannot make for you. Everything the protocol already enforces —
+origin pinning, window binding, instance identity, the gated handshake, payload validation on both
+ends — is on by default and is not something you should be re-implementing by hand.
+
+1. **Restrict who may embed the feature.** Send
+   `Content-Security-Policy: frame-ancestors <hosts>` on the response that serves the feature
+   document. Origin pinning keeps a conversation consistent; only `frame-ancestors` decides whether
+   a page was ever allowed to frame you.
+2. **Authorise on the server.** A message that crossed the boundary is not an authorised operation.
+   Protected work needs credentials the feature's own backend validates.
+3. **Choose the envelope deliberately.** `v2` with a pre-shared key is the confidentiality control;
+   `v1` is time-window obfuscation and buys deterrence only. Provision and rotate the `v2` key
+   yourself; a key is never baked into a built artifact. A handshake that cannot agree on an
+   encrypted transport falls back to plaintext; where that would be unacceptable, drive
+   `@hyperfrontend/nexus` directly and set `security.mode: 'fail-closed'` on the channel so the
+   connection is denied instead.
+4. **Declare schemas and a contract version.** Actions without a schema pass unvalidated, and a side
+   without a version always passes the compatibility gate. Both are how drift is caught early.
+5. **Grant capability narrowly.** Delegate only the Permissions-Policy features the integration
+   needs, and price a `sandbox` posture against what the product actually requires.
+6. **Serve everything over HTTPS**, host and feature alike.
+7. **Keep dependencies updated** on both sides of the boundary, and pair that with the page-integrity
+   controls this model deliberately leaves to you: Content Security Policy, Trusted Types,
+   Subresource Integrity, and dependency provenance.
 
 ## Security Updates
 
@@ -73,10 +112,6 @@ Security updates will be released as patch versions and documented in the [CHANG
 
 ## Supported Versions
 
-We currently provide security updates for:
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 0.0.x   | :white_check_mark: |
-
-As the project matures, we will update this table to reflect our long-term support policy.
+Security updates are provided for the latest published version of each `@hyperfrontend/*` package.
+Older releases receive no backports. A long-term support policy will replace this section once the
+packages settle on a stable release cadence.

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.cjs.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const _Date = globalThis.Date;
+const _Reflect = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect.construct(_Date, args);
+}
+const dateNow = _Date.now;
+exports.createDate = createDate;
+exports.dateNow = dateNow;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.esm.js

@@ -0,0 +1,8 @@
+const _Date = globalThis.Date;
+const _Reflect = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect.construct(_Date, args);
+}
+const dateNow = _Date.now;
+
+export { createDate, dateNow };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+exports.createError = createError;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js

@@ -0,0 +1,5 @@
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+
+export { createError };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.cjs.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const _Math = globalThis.Math;
+const floor = _Math.floor;
+exports.floor = floor;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.esm.js

@@ -0,0 +1,4 @@
+const _Math = globalThis.Math;
+const floor = _Math.floor;
+
+export { floor };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/number/index.cjs.js

@@ -0,0 +1,4 @@
+'use strict';
+const _isNaN = globalThis.isNaN;
+const globalIsNaN = _isNaN;
+exports.globalIsNaN = globalIsNaN;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/number/index.esm.js

@@ -0,0 +1,5 @@
+
+const _isNaN = globalThis.isNaN;
+const globalIsNaN = _isNaN;
+
+export { globalIsNaN };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const _Object = globalThis.Object;
+const freeze = _Object.freeze;
+exports.freeze = freeze;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js

@@ -0,0 +1,4 @@
+const _Object = globalThis.Object;
+const freeze = _Object.freeze;
+
+export { freeze };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.cjs.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const _Promise = globalThis.Promise;
+const _Reflect = globalThis.Reflect;
+const createPromise = (executor) => _Reflect.construct(_Promise, [executor]);
+exports.createPromise = createPromise;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.esm.js

@@ -0,0 +1,5 @@
+const _Promise = globalThis.Promise;
+const _Reflect = globalThis.Reflect;
+const createPromise = (executor) => _Reflect.construct(_Promise, [executor]);
+
+export { createPromise };

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/timers/index.cjs.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const _setTimeout = globalThis.setTimeout;
+const _setInterval = globalThis.setInterval;
+const _clearTimeout = globalThis.clearTimeout;
+const _clearInterval = globalThis.clearInterval;
+const setTimeout = (callback, delay, ...args) => _setTimeout(callback, delay, ...args);
+const setInterval = (callback, delay, ...args) => _setInterval(callback, delay, ...args);
+const clearTimeout = (id) => {
+    _clearTimeout(id);
+};
+const clearInterval = (id) => {
+    _clearInterval(id);
+};
+exports.clearInterval = clearInterval;
+exports.clearTimeout = clearTimeout;
+exports.setInterval = setInterval;
+exports.setTimeout = setTimeout;

package/_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/timers/index.esm.js

@@ -0,0 +1,14 @@
+const _setTimeout = globalThis.setTimeout;
+const _setInterval = globalThis.setInterval;
+const _clearTimeout = globalThis.clearTimeout;
+const _clearInterval = globalThis.clearInterval;
+const setTimeout = (callback, delay, ...args) => _setTimeout(callback, delay, ...args);
+const setInterval = (callback, delay, ...args) => _setInterval(callback, delay, ...args);
+const clearTimeout = (id) => {
+    _clearTimeout(id);
+};
+const clearInterval = (id) => {
+    _clearInterval(id);
+};
+
+export { clearInterval, clearTimeout, setInterval, setTimeout };

package/bundle/index.iife.js

@@ -1,102 +1,29 @@
 var HyperfrontendTimeUtils = (function (exports) {
     'use strict';
 
-    /**
-     * Safe copies of Date built-in via factory function and static methods.
-     *
-     * Since constructors cannot be safely captured via Object.assign, this module
-     * provides a factory function that uses Reflect.construct internally.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/date
-     */
-    // Capture references at module initialization time
     const _Date = globalThis.Date;
     const _Reflect$2 = globalThis.Reflect;
     function createDate(...args) {
         return _Reflect$2.construct(_Date, args);
     }
-    /**
-     * (Safe copy) Returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
-     */
     const dateNow = _Date.now;
 
-    /**
-     * Safe copies of Object built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
-     */
-    // Capture references at module initialization time
     const _Object = globalThis.Object;
-    /**
-     * (Safe copy) Prevents modification of existing property attributes and values,
-     * and prevents the addition of new properties.
-     */
     const freeze = _Object.freeze;
 
-    /**
-     * Safe copies of Timer/Scheduling built-in functions.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/timers
-     */
-    // Capture references at module initialization time
     const _setTimeout = globalThis.setTimeout;
     const _setInterval = globalThis.setInterval;
     const _clearTimeout = globalThis.clearTimeout;
     const _clearInterval = globalThis.clearInterval;
-    /**
-     * (Safe copy) Sets a timer which executes a function once the timer expires.
-     *
-     * @param callback - Function to call when the timer elapses.
-     * @param delay - Time in milliseconds before executing.
-     * @param args - Additional arguments to pass to the callback.
-     * @returns A numeric ID for the timer.
-     */
     const setTimeout = (callback, delay, ...args) => _setTimeout(callback, delay, ...args);
-    /**
-     * (Safe copy) Repeatedly calls a function with a fixed time delay between each call.
-     *
-     * @param callback - Function to call at each interval.
-     * @param delay - Time in milliseconds between calls.
-     * @param args - Additional arguments to pass to the callback.
-     * @returns A numeric ID for the interval.
-     */
     const setInterval = (callback, delay, ...args) => _setInterval(callback, delay, ...args);
-    /**
-     * (Safe copy) Cancels a timeout previously established by setTimeout.
-     *
-     * @param id - The identifier of the timeout to cancel.
-     */
     const clearTimeout = (id) => {
         _clearTimeout(id);
     };
-    /**
-     * (Safe copy) Cancels a timed, repeating action previously established by setInterval.
-     *
-     * @param id - The identifier of the interval to cancel.
-     */
     const clearInterval = (id) => {
         _clearInterval(id);
     };
 
-    /**
-     * Creates an interval loop that invokes one or more subscribed callback functions
-     * at the specified internal (in milliseconds).
-     *
-     * Allows you to start or stop the interval loop, much like a stop watch.
-     * Allows you to unsubscribe callback functions.
-     *
-     * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
-     * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
-     */
     function createClock(interval = 1000) {
         let clockId = null;
         let subscribers = [];
@@ -123,14 +50,6 @@ var HyperfrontendTimeUtils = (function (exports) {
         return freeze({ start, stop, subscribe, unsubscribe, interval });
     }
 
-    /**
-     * Invokes callback function after the designated time has passed, much like a timer.
-     * Allows you to pause, resume, or reset the progress of time tracked.
-     *
-     * @param callback - The function to invoke after the delay
-     * @param delay - Time in milliseconds to wait until callback is invoked
-     * @returns A Timer instance with pause, resume, and reset methods
-     */
     function createTimer(callback, delay) {
         let timerId = null;
         let start = null;
@@ -139,7 +58,6 @@ var HyperfrontendTimeUtils = (function (exports) {
             if (timerId !== null) {
                 clearTimeout(timerId);
                 const now = dateNow();
-                /* istanbul ignore else - start is always set when timerId is not null */
                 if (start !== null) {
                     remaining -= now - start;
                 }
@@ -163,70 +81,16 @@ var HyperfrontendTimeUtils = (function (exports) {
         return freeze({ pause, resume, reset });
     }
 
-    /**
-     * Safe copies of Error built-ins via factory functions.
-     *
-     * Since constructors cannot be safely captured via Object.assign, this module
-     * provides factory functions that use Reflect.construct internally.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
-     */
-    // Capture references at module initialization time
     const _Error = globalThis.Error;
     const _Reflect$1 = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Error using the captured Error constructor.
-     * Use this instead of `new Error()`.
-     *
-     * @param message - Optional error message.
-     * @param options - Optional error options.
-     * @returns A new Error instance.
-     */
     const createError = (message, options) => _Reflect$1.construct(_Error, [message, options]);
 
-    /**
-     * Safe copies of Math built-in methods.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
-     */
-    // Capture references at module initialization time
     const _Math = globalThis.Math;
-    /**
-     * (Safe copy) Returns the largest integer less than or equal to a number.
-     */
     const floor = _Math.floor;
 
-    /**
-     * Safe copies of Number built-in methods and constants.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/number
-     */
-    // Capture references at module initialization time
     const _isNaN = globalThis.isNaN;
-    // ============================================================================
-    // Global Type Checking (legacy, less strict)
-    // ============================================================================
-    /**
-     * (Safe copy) Global isNaN function (coerces to number first, less strict than Number.isNaN).
-     */
     const globalIsNaN = _isNaN;
 
-    /**
-     * Normalizes a given time to the nearest base time window.
-     *
-     * @param time - The Date object to normalize to the nearest time window
-     * @param baseTimeWindow - The size of the time window in minutes for normalization
-     * @returns A new Date object normalized to the start of the time window
-     */
     function normalizeToBaseTimeWindow(time, baseTimeWindow) {
         if (!time || !(time instanceof Date) || globalIsNaN(time.getTime())) {
             throw createError('Invalid time input');
@@ -240,77 +104,22 @@ var HyperfrontendTimeUtils = (function (exports) {
         return createDate(normalizedTimeInMs);
     }
 
-    /**
-     * Creates a repeating interval that invokes a callback function at regular intervals.
-     *
-     * @param callback - The function to invoke at each interval
-     * @param interval - Time in milliseconds between each callback invocation
-     * @returns A cleanup function that stops the interval when called
-     */
     function setIntervalCallback(callback, interval) {
         const timerId = setInterval(callback, interval);
         return () => clearInterval(timerId);
     }
 
-    /**
-     * Safe copies of Promise built-in methods via factory functions.
-     *
-     * Since constructors cannot be safely captured via Object.assign, this module
-     * provides factory functions that use Reflect.construct internally.
-     *
-     * These references are captured at module initialization time to protect against
-     * prototype pollution attacks. Import only what you need for tree-shaking.
-     *
-     * @module @hyperfrontend/immutable-api-utils/built-in-copy/promise
-     */
-    // Capture references at module initialization time
     const _Promise = globalThis.Promise;
     const _Reflect = globalThis.Reflect;
-    /**
-     * (Safe copy) Creates a new Promise using the captured Promise constructor.
-     * Use this instead of `new Promise()`.
-     *
-     * @param executor - The executor function.
-     * @returns A new Promise instance.
-     */
     const createPromise = (executor) => _Reflect.construct(_Promise, [executor]);
-    /**
-     * (Safe copy) Returns a Promise that resolves with the given value.
-     */
     _Promise.resolve.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that rejects with the given reason.
-     */
     _Promise.reject.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves when all promises resolve.
-     */
     _Promise.all.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves/rejects with the first settled promise.
-     */
     _Promise.race.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves when all promises settle.
-     */
     _Promise.allSettled.bind(_Promise);
-    /**
-     * (Safe copy) Returns a Promise that resolves with the first fulfilled promise.
-     */
     _Promise.any.bind(_Promise);
-    /**
-     * (Safe copy) Creates a Promise along with its resolve and reject functions.
-     * Note: Available only in ES2024+ environments.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _Promise.withResolvers?.bind(_Promise);
 
-    /**
-     * Pauses execution for a specified duration.
-     *
-     * @param milliseconds - The duration to sleep in milliseconds
-     * @returns A promise that resolves after the specified duration
-     */
     function sleep(milliseconds) {
         return createPromise((resolve) => setTimeout(resolve, milliseconds));
     }
@@ -324,4 +133,3 @@ var HyperfrontendTimeUtils = (function (exports) {
     return exports;
 
 })({});
-//# sourceMappingURL=index.iife.js.map

package/bundle/index.iife.min.js

@@ -1,2 +1 @@
 var HyperfrontendTimeUtils=function(e){"use strict";const l=globalThis.Date,t=globalThis.Reflect;function n(...e){return t.construct(l,e)}const i=l.now,o=globalThis.Object.freeze,s=globalThis.setTimeout,r=globalThis.setInterval,a=globalThis.clearTimeout,c=globalThis.clearInterval,u=(e,l,...t)=>s(e,l,...t),b=(e,l,...t)=>r(e,l,...t),T=e=>{c(e)};const f=globalThis.Error,h=globalThis.Reflect,g=(e,l)=>h.construct(f,[e,l]),m=globalThis.Math.floor,d=globalThis.isNaN;const v=globalThis.Promise,p=globalThis.Reflect;return v.resolve.bind(v),v.reject.bind(v),v.all.bind(v),v.race.bind(v),v.allSettled.bind(v),v.any.bind(v),v.withResolvers?.bind(v),e.createClock=function(e=1e3){let l=null,t=[];return o({start:()=>{null===l&&(l=b(()=>{const e=n();t.forEach(l=>l(e))},e))},stop:()=>{null!==l&&(T(l),l=null)},subscribe:e=>{t.push(e)},unsubscribe:e=>{t=t.filter(l=>l!==e)},interval:e})},e.createTimer=function(e,l){let t=null,n=null,s=l;const r=()=>{if(null!==t){a(t);const e=i();null!==n&&(s-=e-n),t=null}},c=()=>{null===t&&(n=i(),t=u(()=>{e(),t=null},s))};return o({pause:r,resume:c,reset:(e=l)=>{r(),s=e,c()}})},e.normalizeToBaseTimeWindow=function(e,l){if(!e||!(e instanceof Date)||d(e.getTime()))throw g("Invalid time input");if(l<=0)throw g("Base time window must be positive");const t=e.getTime(),i=60*l*1e3;return n(m(t/i)*i)},e.setIntervalCallback=function(e,l){const t=b(e,l);return()=>T(t)},e.sleep=function(e){return l=l=>u(l,e),p.construct(v,[l]);var l},e}({});
-//# sourceMappingURL=index.iife.min.js.map