@enormora/wall-clock 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Rackerseder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,243 @@
+# @enormora/wall-clock
+
+Explicit wall-clock time access for TypeScript applications.
+
+`@enormora/wall-clock` provides a small boundary around time-related side effects:
+
+- reading the current timestamp
+- creating the current `Date`
+- scheduling and clearing timeouts
+- scheduling and clearing intervals
+- replacing real time with a deterministic clock in tests
+
+The package is intentionally small. It is meant to make time an explicit dependency instead of letting application code
+call `Date.now()`, `new Date()`, `setTimeout`, or `setInterval` directly.
+
+## Installation
+
+```sh
+npm install @enormora/wall-clock
+```
+
+The package is ESM-only and requires Node.js `^24.15.0 || ^26.0.0`.
+
+The root export keeps both clocks available from one import. Prefer the explicit module subpaths when code only needs one
+clock:
+
+- `@enormora/wall-clock/wall-clock`
+- `@enormora/wall-clock/deterministic-wall-clock`
+
+## Real wall clock
+
+Use `createWallClock()` at the application boundary and pass the resulting `WallClock` into code that needs time.
+
+```ts
+import { createWallClock } from '@enormora/wall-clock/wall-clock';
+
+const wallClock = createWallClock();
+
+console.log(wallClock.currentTimestampInMilliseconds);
+console.log(wallClock.currentDate.toISOString());
+```
+
+The real clock delegates to the runtime:
+
+- `currentTimestampInMilliseconds` uses `Date.now()`
+- `currentDate` returns a new `Date`
+- `setTimeout` and `clearTimeout` call `globalThis`
+- `setInterval` and `clearInterval` call `globalThis`
+
+The timer functions are bound to `globalThis`, so they can be passed around safely.
+
+## Dependency injection
+
+Prefer accepting a `WallClock` as an explicit dependency for code that depends on time.
+
+```ts
+import type { WallClock } from '@enormora/wall-clock/wall-clock';
+
+type Session = {
+    readonly expiresAtTimestampInMilliseconds: number;
+};
+
+export function isSessionExpired(wallClock: WallClock, session: Session): boolean {
+    return wallClock.currentTimestampInMilliseconds >= session.expiresAtTimestampInMilliseconds;
+}
+```
+
+This keeps the core behavior deterministic and easy to test.
+
+## Deterministic wall clock
+
+Use `createDeterministicWallClock()` in tests or deterministic environments.
+
+```ts
+import { createDeterministicWallClock } from '@enormora/wall-clock/deterministic-wall-clock';
+
+const wallClock = createDeterministicWallClock({
+    initialCurrentTimestampInMilliseconds: 1_704_067_200_000
+});
+
+console.log(wallClock.currentDate.toISOString());
+
+wallClock.advanceByMilliseconds(1000);
+
+console.log(wallClock.currentTimestampInMilliseconds);
+```
+
+The deterministic clock implements the same `WallClock` interface and adds:
+
+- `setCurrentTimestampInMilliseconds(nextTimestampInMilliseconds)`
+- `advanceByMilliseconds(delayInMilliseconds)`
+
+## Testing timers
+
+The deterministic clock runs scheduled callbacks when time is advanced far enough.
+
+```ts
+import { deepEqual } from 'node:assert/strict';
+import { createDeterministicWallClock } from '@enormora/wall-clock/deterministic-wall-clock';
+
+const wallClock = createDeterministicWallClock();
+const calls: string[] = [];
+
+wallClock.setTimeout(
+    (value) => {
+        calls.push(value);
+    },
+    100,
+    'done'
+);
+
+wallClock.advanceByMilliseconds(99);
+deepEqual(calls, []);
+
+wallClock.advanceByMilliseconds(1);
+deepEqual(calls, ['done']);
+```
+
+Intervals run once for each elapsed interval.
+
+```ts
+import { equal } from 'node:assert/strict';
+import { createDeterministicWallClock } from '@enormora/wall-clock/deterministic-wall-clock';
+
+const wallClock = createDeterministicWallClock();
+let count = 0;
+
+const intervalIdentifier = wallClock.setInterval(() => {
+    count += 1;
+}, 100);
+
+wallClock.advanceByMilliseconds(250);
+equal(count, 2);
+
+wallClock.clearInterval(intervalIdentifier);
+wallClock.advanceByMilliseconds(500);
+equal(count, 2);
+```
+
+## Timer behavior
+
+Timeouts:
+
+- execute once
+- execute only after the clock reaches their scheduled timestamp
+- execute in scheduled timestamp order
+- execute in registration order when multiple timeouts share the same scheduled timestamp
+- can use a delay of `0`
+- reject negative and non-finite delays
+
+Intervals:
+
+- execute repeatedly
+- execute once per elapsed interval when time advances
+- stop after `clearInterval`
+- reject `0`, negative, and non-finite delays
+
+The deterministic clock intentionally rejects zero-delay intervals because they cannot advance safely without creating an
+infinite loop.
+
+## API
+
+```ts
+export type WallClock = {
+    readonly currentTimestampInMilliseconds: number;
+    readonly currentDate: Date;
+    readonly setTimeout: <HandlerArguments extends readonly unknown[]>(
+        handler: (...handlerArguments: HandlerArguments) => void,
+        delayInMilliseconds: number,
+        ...handlerArguments: HandlerArguments
+    ) => ReturnType<typeof globalThis.setTimeout>;
+    readonly clearTimeout: (timeoutIdentifier: ReturnType<typeof globalThis.setTimeout>) => void;
+    readonly setInterval: <HandlerArguments extends readonly unknown[]>(
+        handler: (...handlerArguments: HandlerArguments) => void,
+        delayInMilliseconds: number,
+        ...handlerArguments: HandlerArguments
+    ) => ReturnType<typeof globalThis.setInterval>;
+    readonly clearInterval: (intervalIdentifier: ReturnType<typeof globalThis.setInterval>) => void;
+};
+```
+
+```ts
+export type DeterministicWallClock = WallClock & {
+    readonly setCurrentTimestampInMilliseconds: (nextTimestampInMilliseconds: number) => void;
+    readonly advanceByMilliseconds: (delayInMilliseconds: number) => void;
+};
+```
+
+```ts
+export function createWallClock(): WallClock;
+```
+
+```ts
+export function createDeterministicWallClock(options?: {
+    readonly initialCurrentTimestampInMilliseconds?: number;
+}): DeterministicWallClock;
+```
+
+## Development
+
+Install dependencies:
+
+```sh
+npm clean-install
+```
+
+Compile:
+
+```sh
+just compile
+```
+
+Run lint checks:
+
+```sh
+just lint
+```
+
+Run tests:
+
+```sh
+just test
+```
+
+Run a Packtory dry-run:
+
+```sh
+just packtory-dry-run
+```
+
+## Publishing
+
+The package is prepared with Packtory. The dry-run command validates the package shape without publishing.
+
+```sh
+just packtory-dry-run
+```
+
+Actual publishing should use the repository release workflow once configured.
+
+## License
+
+MIT

package/deterministic-wall-clock.d.ts

@@ -0,0 +1,10 @@
+import type { WallClock } from './wall-clock.ts';
+export type DeterministicWallClock = WallClock & {
+    readonly setCurrentTimestampInMilliseconds: (nextTimestampInMilliseconds: number) => void;
+    readonly advanceByMilliseconds: (delayInMilliseconds: number) => void;
+};
+export type DeterministicWallClockOptions = {
+    readonly initialCurrentTimestampInMilliseconds?: number;
+};
+export declare function createDeterministicWallClock(options?: DeterministicWallClockOptions): DeterministicWallClock;
+//# sourceMappingURL=deterministic-wall-clock.d.ts.map

package/deterministic-wall-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic-wall-clock.d.ts","sourceRoot":"","sources":["../../../source/deterministic-wall-clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG;IAC7C,QAAQ,CAAC,iCAAiC,EAAE,CAAC,2BAA2B,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1F,QAAQ,CAAC,qBAAqB,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IACxC,QAAQ,CAAC,qCAAqC,CAAC,EAAE,MAAM,CAAC;CAC3D,CAAC;AAwIF,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,6BAAkC,GAAG,sBAAsB,CAuChH"}

package/deterministic-wall-clock.js

@@ -0,0 +1,115 @@
+import { validateIntervalDelayInMilliseconds, validateTimeoutDelayInMilliseconds } from "./timer-delay.js";
+function createTimeoutController(currentTimestampInMilliseconds) {
+    let nextTimeoutIdentifier = 0;
+    const timeoutRegistrations = new Map();
+    function runDueTimeoutRegistrations() {
+        const dueTimeoutEntries = Array.from(timeoutRegistrations.entries())
+            .filter(([, timeoutRegistration]) => {
+            return timeoutRegistration.executionTimestampInMilliseconds <= currentTimestampInMilliseconds();
+        })
+            .toSorted((firstTimeoutEntry, secondTimeoutEntry) => {
+            const [firstTimeoutIdentifier, firstTimeoutRegistration] = firstTimeoutEntry;
+            const [secondTimeoutIdentifier, secondTimeoutRegistration] = secondTimeoutEntry;
+            if (firstTimeoutRegistration.executionTimestampInMilliseconds !==
+                secondTimeoutRegistration.executionTimestampInMilliseconds) {
+                return (firstTimeoutRegistration.executionTimestampInMilliseconds -
+                    secondTimeoutRegistration.executionTimestampInMilliseconds);
+            }
+            return firstTimeoutIdentifier - secondTimeoutIdentifier;
+        });
+        dueTimeoutEntries.forEach(([timeoutIdentifier, timeoutRegistration]) => {
+            timeoutRegistrations.delete(timeoutIdentifier);
+            timeoutRegistration.execute();
+        });
+    }
+    return {
+        runDueTimeoutRegistrations,
+        setTimeout(handler, delayInMilliseconds, ...handlerArguments) {
+            validateTimeoutDelayInMilliseconds(delayInMilliseconds);
+            const timeoutIdentifier = nextTimeoutIdentifier;
+            nextTimeoutIdentifier += 1;
+            timeoutRegistrations.set(timeoutIdentifier, {
+                execute: () => {
+                    handler(...handlerArguments);
+                },
+                executionTimestampInMilliseconds: currentTimestampInMilliseconds() + delayInMilliseconds
+            });
+            return timeoutIdentifier;
+        },
+        clearTimeout(timeoutIdentifier) {
+            timeoutRegistrations.delete(timeoutIdentifier);
+        }
+    };
+}
+function createIntervalController(currentTimestampInMilliseconds) {
+    let nextIntervalIdentifier = 0;
+    const intervalRegistrations = new Map();
+    function runDueIntervalRegistrations() {
+        intervalRegistrations.forEach((intervalRegistration, intervalIdentifier) => {
+            const { delayInMilliseconds, execute } = intervalRegistration;
+            let { nextExecutionTimestampInMilliseconds } = intervalRegistration;
+            while (nextExecutionTimestampInMilliseconds <= currentTimestampInMilliseconds()) {
+                execute();
+                if (!intervalRegistrations.has(intervalIdentifier)) {
+                    return;
+                }
+                nextExecutionTimestampInMilliseconds += delayInMilliseconds;
+                intervalRegistrations.set(intervalIdentifier, {
+                    delayInMilliseconds,
+                    execute,
+                    nextExecutionTimestampInMilliseconds
+                });
+            }
+        });
+    }
+    return {
+        runDueIntervalRegistrations,
+        setInterval(handler, delayInMilliseconds, ...handlerArguments) {
+            validateIntervalDelayInMilliseconds(delayInMilliseconds);
+            const intervalIdentifier = nextIntervalIdentifier;
+            nextIntervalIdentifier += 1;
+            intervalRegistrations.set(intervalIdentifier, {
+                delayInMilliseconds,
+                execute: () => {
+                    handler(...handlerArguments);
+                },
+                nextExecutionTimestampInMilliseconds: currentTimestampInMilliseconds() + delayInMilliseconds
+            });
+            return intervalIdentifier;
+        },
+        clearInterval(intervalIdentifier) {
+            intervalRegistrations.delete(intervalIdentifier);
+        }
+    };
+}
+export function createDeterministicWallClock(options = {}) {
+    const { initialCurrentTimestampInMilliseconds = 0 } = options;
+    let currentTimestampInMilliseconds = initialCurrentTimestampInMilliseconds;
+    function currentTimestampReader() {
+        return currentTimestampInMilliseconds;
+    }
+    const timeoutController = createTimeoutController(currentTimestampReader);
+    const intervalController = createIntervalController(currentTimestampReader);
+    return {
+        get currentTimestampInMilliseconds() {
+            return currentTimestampInMilliseconds;
+        },
+        get currentDate() {
+            return new Date(currentTimestampInMilliseconds);
+        },
+        setCurrentTimestampInMilliseconds(nextTimestampInMilliseconds) {
+            currentTimestampInMilliseconds = nextTimestampInMilliseconds;
+        },
+        advanceByMilliseconds(delayInMilliseconds) {
+            validateTimeoutDelayInMilliseconds(delayInMilliseconds);
+            currentTimestampInMilliseconds += delayInMilliseconds;
+            intervalController.runDueIntervalRegistrations();
+            timeoutController.runDueTimeoutRegistrations();
+        },
+        setTimeout: timeoutController.setTimeout,
+        clearTimeout: timeoutController.clearTimeout,
+        setInterval: intervalController.setInterval,
+        clearInterval: intervalController.clearInterval
+    };
+}
+//# sourceMappingURL=deterministic-wall-clock.js.map

package/deterministic-wall-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic-wall-clock.js","sourceRoot":"","sources":["../../../source/deterministic-wall-clock.ts"],"names":[],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,5 @@
+export { createWallClock } from './wall-clock.ts';
+export type { WallClock } from './wall-clock.ts';
+export { createDeterministicWallClock } from './deterministic-wall-clock.ts';
+export type { DeterministicWallClock, DeterministicWallClockOptions } from './deterministic-wall-clock.ts';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAC7E,YAAY,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC"}

package/index.js

@@ -0,0 +1,3 @@
+export { createWallClock } from "./wall-clock.js";
+export { createDeterministicWallClock } from "./deterministic-wall-clock.js";
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC"}

package/package.json

@@ -0,0 +1,26 @@
+{
+    "author": "Christian Rackerseder <git@echooff.de>",
+    "exports": {
+        ".": {
+            "import": "./index.js",
+            "types": "./index.d.ts"
+        },
+        "./deterministic-wall-clock": {
+            "import": "./deterministic-wall-clock.js",
+            "types": "./deterministic-wall-clock.d.ts"
+        },
+        "./wall-clock": {
+            "import": "./wall-clock.js",
+            "types": "./wall-clock.d.ts"
+        }
+    },
+    "license": "MIT",
+    "name": "@enormora/wall-clock",
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@github.com/enormora/wall-clock.git"
+    },
+    "sideEffects": false,
+    "type": "module",
+    "version": "0.0.1"
+}

package/sbom.cdx.json

@@ -0,0 +1,30 @@
+{
+    "$schema": "http://cyclonedx.org/schema/bom-1.6.schema.json",
+    "bomFormat": "CycloneDX",
+    "specVersion": "1.6",
+    "version": 1,
+    "metadata": {
+        "tools": {
+            "components": [
+                {
+                    "type": "application",
+                    "name": "packtory",
+                    "version": "0.0.43"
+                }
+            ]
+        },
+        "component": {
+            "type": "library",
+            "name": "@enormora/wall-clock",
+            "version": "0.0.1",
+            "bom-ref": "pkg:npm/@enormora/wall-clock@0.0.1",
+            "purl": "pkg:npm/@enormora/wall-clock@0.0.1"
+        }
+    },
+    "components": [],
+    "dependencies": [
+        {
+            "ref": "pkg:npm/@enormora/wall-clock@0.0.1"
+        }
+    ]
+}

package/timer-delay.js

@@ -0,0 +1,18 @@
+export function validateFiniteDelayInMilliseconds(delayInMilliseconds) {
+    if (!Number.isFinite(delayInMilliseconds)) {
+        throw new TypeError('Invalid delay, must be a finite number');
+    }
+}
+export function validateTimeoutDelayInMilliseconds(delayInMilliseconds) {
+    validateFiniteDelayInMilliseconds(delayInMilliseconds);
+    if (delayInMilliseconds < 0) {
+        throw new RangeError(`Invalid timeout delay ${delayInMilliseconds}, must be greater than or equal to 0`);
+    }
+}
+export function validateIntervalDelayInMilliseconds(delayInMilliseconds) {
+    validateFiniteDelayInMilliseconds(delayInMilliseconds);
+    if (delayInMilliseconds <= 0) {
+        throw new RangeError(`Invalid interval delay ${delayInMilliseconds}, must be greater than 0`);
+    }
+}
+//# sourceMappingURL=timer-delay.js.map

package/timer-delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer-delay.js","sourceRoot":"","sources":["../../../source/timer-delay.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iCAAiC,CAAC,mBAA2B;IACzE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;IAClE,CAAC;AACL,CAAC;AAED,MAAM,UAAU,kCAAkC,CAAC,mBAA2B;IAC1E,iCAAiC,CAAC,mBAAmB,CAAC,CAAC;IAEvD,IAAI,mBAAmB,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,UAAU,CAAC,yBAAyB,mBAAmB,sCAAsC,CAAC,CAAC;IAC7G,CAAC;AACL,CAAC;AAED,MAAM,UAAU,mCAAmC,CAAC,mBAA2B;IAC3E,iCAAiC,CAAC,mBAAmB,CAAC,CAAC;IAEvD,IAAI,mBAAmB,IAAI,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,UAAU,CAAC,0BAA0B,mBAAmB,0BAA0B,CAAC,CAAC;IAClG,CAAC;AACL,CAAC"}

package/wall-clock.d.ts

@@ -0,0 +1,10 @@
+export type WallClock = {
+    readonly currentTimestampInMilliseconds: number;
+    readonly currentDate: Date;
+    readonly setTimeout: <HandlerArguments extends readonly unknown[]>(handler: (...handlerArguments: HandlerArguments) => void, delayInMilliseconds: number, ...handlerArguments: HandlerArguments) => ReturnType<typeof globalThis.setTimeout>;
+    readonly clearTimeout: (timeoutIdentifier: ReturnType<typeof globalThis.setTimeout>) => void;
+    readonly setInterval: <HandlerArguments extends readonly unknown[]>(handler: (...handlerArguments: HandlerArguments) => void, delayInMilliseconds: number, ...handlerArguments: HandlerArguments) => ReturnType<typeof globalThis.setInterval>;
+    readonly clearInterval: (intervalIdentifier: ReturnType<typeof globalThis.setInterval>) => void;
+};
+export declare function createWallClock(): WallClock;
+//# sourceMappingURL=wall-clock.d.ts.map

package/wall-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-clock.d.ts","sourceRoot":"","sources":["../../../source/wall-clock.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACpB,QAAQ,CAAC,8BAA8B,EAAE,MAAM,CAAC;IAChD,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,CAAC,gBAAgB,SAAS,SAAS,OAAO,EAAE,EAC7D,OAAO,EAAE,CAAC,GAAG,gBAAgB,EAAE,gBAAgB,KAAK,IAAI,EACxD,mBAAmB,EAAE,MAAM,EAC3B,GAAG,gBAAgB,EAAE,gBAAgB,KACpC,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,YAAY,EAAE,CAAC,iBAAiB,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC7F,QAAQ,CAAC,WAAW,EAAE,CAAC,gBAAgB,SAAS,SAAS,OAAO,EAAE,EAC9D,OAAO,EAAE,CAAC,GAAG,gBAAgB,EAAE,gBAAgB,KAAK,IAAI,EACxD,mBAAmB,EAAE,MAAM,EAC3B,GAAG,gBAAgB,EAAE,gBAAgB,KACpC,UAAU,CAAC,OAAO,UAAU,CAAC,WAAW,CAAC,CAAC;IAC/C,QAAQ,CAAC,aAAa,EAAE,CAAC,kBAAkB,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;CACnG,CAAC;AAEF,wBAAgB,eAAe,IAAI,SAAS,CAkB3C"}

package/wall-clock.js

@@ -0,0 +1,15 @@
+export function createWallClock() {
+    return {
+        get currentTimestampInMilliseconds() {
+            return Date.now();
+        },
+        get currentDate() {
+            return new Date();
+        },
+        setTimeout: globalThis.setTimeout.bind(globalThis),
+        clearTimeout: globalThis.clearTimeout.bind(globalThis),
+        setInterval: globalThis.setInterval.bind(globalThis),
+        clearInterval: globalThis.clearInterval.bind(globalThis)
+    };
+}
+//# sourceMappingURL=wall-clock.js.map

package/wall-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-clock.js","sourceRoot":"","sources":["../../../source/wall-clock.ts"],"names":[],"mappings":"AAiBA,MAAM,UAAU,eAAe;IAC3B,OAAO;QACH,IAAI,8BAA8B;YAC9B,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,CAAC;QAED,IAAI,WAAW;YACX,OAAO,IAAI,IAAI,EAAE,CAAC;QACtB,CAAC;QAED,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC;QAElD,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC;QAEtD,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC;QAEpD,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC;KAC3D,CAAC;AACN,CAAC"}