rp2040js 0.19.4 → 1.0.1

package/dist/esm/peripherals/rtc.js

@@ -43,10 +43,10 @@ export class RP2040RTC extends BasePeripheral {
         this.setup1 = 0;
         this.ctrl = 0;
         this.baseline = new Date(2021, 0, 1);
-        this.baselineMicros = 0;
+        this.baselineNanos = 0;
     }
     readUint32(offset) {
-        const date = new Date(this.baseline.getTime() + (this.rp2040.clock.micros - this.baselineMicros) / 1000);
+        const date = new Date(this.baseline.getTime() + (this.rp2040.clock.nanos - this.baselineNanos) / 1000000);
         switch (offset) {
             case RTC_SETUP0:
                 return this.setup0;
@@ -96,7 +96,7 @@ export class RP2040RTC extends BasePeripheral {
                         const min = (this.setup1 >> SETUP_1_MIN_SHIFT) & SETUP_1_MIN_MASK;
                         const sec = (this.setup1 >> SETUP_1_SEC_SHIFT) & SETUP_1_SEC_MASK;
                         this.baseline = new Date(year, month - 1, day, hour, min, sec);
-                        this.baselineMicros = this.rp2040.clock.micros;
+                        this.baselineNanos = this.rp2040.clock.nanos;
                         this.ctrl &= ~RTC_LOAD_BITS;
                     }
                 }

package/dist/esm/peripherals/timer.js

@@ -20,35 +20,34 @@ const ALARM_2 = 1 << 2;
 const ALARM_3 = 1 << 3;
 const timerInterrupts = [IRQ.TIMER_0, IRQ.TIMER_1, IRQ.TIMER_2, IRQ.TIMER_3];
 class RPTimerAlarm {
-    constructor(name, bitValue) {
-        this.name = name;
+    constructor(bitValue, clockAlarm) {
         this.bitValue = bitValue;
+        this.clockAlarm = clockAlarm;
         this.armed = false;
         this.targetMicros = 0;
-        this.timer = null;
     }
 }
 export class RPTimer extends BasePeripheral {
     constructor(rp2040, name) {
         super(rp2040, name);
         this.latchedTimeHigh = 0;
-        this.alarms = [
-            new RPTimerAlarm('Alarm 0', ALARM_0),
-            new RPTimerAlarm('Alarm 1', ALARM_1),
-            new RPTimerAlarm('Alarm 2', ALARM_2),
-            new RPTimerAlarm('Alarm 3', ALARM_3),
-        ];
         this.intRaw = 0;
         this.intEnable = 0;
         this.intForce = 0;
         this.paused = false;
         this.clock = rp2040.clock;
+        this.alarms = [
+            new RPTimerAlarm(ALARM_0, this.clock.createAlarm(() => this.fireAlarm(0))),
+            new RPTimerAlarm(ALARM_1, this.clock.createAlarm(() => this.fireAlarm(1))),
+            new RPTimerAlarm(ALARM_2, this.clock.createAlarm(() => this.fireAlarm(2))),
+            new RPTimerAlarm(ALARM_3, this.clock.createAlarm(() => this.fireAlarm(3))),
+        ];
     }
     get intStatus() {
         return (this.intRaw & this.intEnable) | this.intForce;
     }
     readUint32(offset) {
-        const time = this.clock.micros;
+        const time = this.clock.nanos / 1000;
         switch (offset) {
             case TIMEHR:
                 return this.latchedTimeHigh;
@@ -93,11 +92,10 @@ export class RPTimer extends BasePeripheral {
             case ALARM3: {
                 const alarmIndex = (offset - ALARM0) / 4;
                 const alarm = this.alarms[alarmIndex];
-                const delta = (value - this.clock.micros) >>> 0;
-                this.disarmAlarm(alarm);
+                const deltaMicros = (value - this.clock.nanos / 1000) >>> 0;
                 alarm.armed = true;
                 alarm.targetMicros = value;
-                alarm.timer = this.clock.createTimer(delta, () => this.fireAlarm(alarmIndex));
+                alarm.clockAlarm.schedule(deltaMicros * 1000);
                 break;
             }
             case ARMED:
@@ -143,10 +141,7 @@ export class RPTimer extends BasePeripheral {
         }
     }
     disarmAlarm(alarm) {
-        if (alarm.timer) {
-            this.clock.deleteTimer(alarm.timer);
-            alarm.timer = null;
-        }
+        alarm.clockAlarm.cancel();
         alarm.armed = false;
     }
 }

package/dist/esm/peripherals/usb.d.ts

@@ -1,3 +1,4 @@
+import { RP2040 } from '../rp2040.js';
 import { BasePeripheral } from './peripheral.js';
 export declare class RPUSBController extends BasePeripheral {
     private mainCtrl;
@@ -6,6 +7,9 @@ export declare class RPUSBController extends BasePeripheral {
     private intForce;
     private sieStatus;
     private buffStatus;
+    private readonly endpointReadAlarms;
+    private readonly endpointWriteAlarms;
+    private readonly resetAlarm;
     onUSBEnabled?: () => void;
     onResetReceived?: () => void;
     onEndpointWrite?: (endpoint: number, buffer: Uint8Array) => void;
@@ -13,6 +17,7 @@ export declare class RPUSBController extends BasePeripheral {
     readDelayMicroseconds: number;
     writeDelayMicroseconds: number;
     get intStatus(): number;
+    constructor(rp2040: RP2040, name: string);
     readUint32(offset: number): number;
     writeUint32(offset: number, value: number): void;
     private readEndpointControlReg;

package/dist/esm/peripherals/usb.js

@@ -1,5 +1,6 @@
 import { IRQ } from '../irq.js';
 import { BasePeripheral } from './peripheral.js';
+const ENDPOINT_COUNT = 16;
 // USB DPSRAM Registers
 const EP1_IN_CONTROL = 0x8;
 const EP0_IN_BUFFER_CONTROL = 0x80;
@@ -77,20 +78,52 @@ const SIE_WRITECLEAR_MASK = SIE_DATA_SEQ_ERROR |
     SIE_TRANS_COMPLETE |
     SIE_SETUP_REC |
     SIE_RESUME;
+class USBEndpointAlarm {
+    constructor(alarm) {
+        this.alarm = alarm;
+        this.buffers = [];
+    }
+    schedule(buffer, delayNanos) {
+        this.buffers.push(buffer);
+        this.alarm.schedule(delayNanos);
+    }
+}
 export class RPUSBController extends BasePeripheral {
-    constructor() {
-        super(...arguments);
+    get intStatus() {
+        return (this.intRaw & this.intEnable) | this.intForce;
+    }
+    constructor(rp2040, name) {
+        super(rp2040, name);
         this.mainCtrl = 0;
         this.intRaw = 0;
         this.intEnable = 0;
         this.intForce = 0;
         this.sieStatus = 0;
         this.buffStatus = 0;
-        this.readDelayMicroseconds = 1;
-        this.writeDelayMicroseconds = 1;
-    }
-    get intStatus() {
-        return (this.intRaw & this.intEnable) | this.intForce;
+        this.readDelayMicroseconds = 10;
+        this.writeDelayMicroseconds = 10; // Determined empirically
+        const clock = rp2040.clock;
+        this.endpointReadAlarms = [];
+        this.endpointWriteAlarms = [];
+        for (let i = 0; i < ENDPOINT_COUNT; ++i) {
+            this.endpointReadAlarms.push(new USBEndpointAlarm(clock.createAlarm(() => {
+                const buffer = this.endpointReadAlarms[i].buffers.shift();
+                if (buffer) {
+                    this.finishRead(i, buffer);
+                }
+            })));
+            this.endpointWriteAlarms.push(new USBEndpointAlarm(clock.createAlarm(() => {
+                var _a;
+                for (const buffer of this.endpointWriteAlarms[i].buffers) {
+                    (_a = this.onEndpointWrite) === null || _a === void 0 ? void 0 : _a.call(this, i, buffer);
+                }
+                this.endpointWriteAlarms[i].buffers = [];
+            })));
+        }
+        this.resetAlarm = clock.createAlarm(() => {
+            this.sieStatus |= SIE_BUS_RESET;
+            this.sieStatusUpdated();
+        });
     }
     readUint32(offset) {
         switch (offset) {
@@ -164,7 +197,7 @@ export class RPUSBController extends BasePeripheral {
         return this.readEndpointControlReg(endpoint, out) & 0xffc0;
     }
     DPRAMUpdated(offset, value) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         if (value & USB_BUF_CTRL_AVAILABLE &&
             offset >= EP0_IN_BUFFER_CONTROL &&
             offset <= EP15_OUT_BUFFER_CONTROL) {
@@ -177,31 +210,6 @@ export class RPUSBController extends BasePeripheral {
                 doubleBuffer = !!(control & USB_CTRL_DOUBLE_BUF);
                 interrupt = !!(control & USB_CTRL_INTERRUPT_PER_TRANSFER);
             }
-            const bufferLength = value & USB_BUF_CTRL_LEN_MASK;
-            const bufferOffset = this.getEndpointBufferOffset(endpoint, bufferOut);
-            this.debug(`Start USB transfer, endPoint=${endpoint}, direction=${bufferOut ? 'out' : 'in'} buffer=${bufferOffset.toString(16)} length=${bufferLength}`);
-            value &= ~USB_BUF_CTRL_AVAILABLE;
-            this.rp2040.usbDPRAMView.setUint32(offset, value, true);
-            if (bufferOut) {
-                (_a = this.onEndpointRead) === null || _a === void 0 ? void 0 : _a.call(this, endpoint, bufferLength);
-            }
-            else {
-                value &= ~USB_BUF_CTRL_FULL;
-                this.rp2040.usbDPRAMView.setUint32(offset, value, true);
-                const buffer = this.rp2040.usbDPRAM.slice(bufferOffset, bufferOffset + bufferLength);
-                if (interrupt || !doubleBuffer) {
-                    this.indicateBufferReady(endpoint, false);
-                }
-                if (this.writeDelayMicroseconds) {
-                    this.rp2040.clock.createTimer(this.writeDelayMicroseconds, () => {
-                        var _a;
-                        (_a = this.onEndpointWrite) === null || _a === void 0 ? void 0 : _a.call(this, endpoint, buffer);
-                    });
-                }
-                else {
-                    (_b = this.onEndpointWrite) === null || _b === void 0 ? void 0 : _b.call(this, endpoint, buffer);
-                }
-            }
             if (doubleBuffer && (value >> USB_BUF1_SHIFT) & USB_BUF_CTRL_AVAILABLE) {
                 const bufferLength = (value >> USB_BUF1_SHIFT) & USB_BUF_CTRL_LEN_MASK;
                 const bufferOffset = this.getEndpointBufferOffset(endpoint, bufferOut) + USB_BUF1_OFFSET;
@@ -209,35 +217,37 @@ export class RPUSBController extends BasePeripheral {
                 value &= ~(USB_BUF_CTRL_AVAILABLE << USB_BUF1_SHIFT);
                 this.rp2040.usbDPRAMView.setUint32(offset, value, true);
                 if (bufferOut) {
-                    (_c = this.onEndpointRead) === null || _c === void 0 ? void 0 : _c.call(this, endpoint, bufferLength);
+                    (_a = this.onEndpointRead) === null || _a === void 0 ? void 0 : _a.call(this, endpoint, bufferLength);
                 }
                 else {
                     value &= ~(USB_BUF_CTRL_FULL << USB_BUF1_SHIFT);
                     this.rp2040.usbDPRAMView.setUint32(offset, value, true);
                     const buffer = this.rp2040.usbDPRAM.slice(bufferOffset, bufferOffset + bufferLength);
                     this.indicateBufferReady(endpoint, false);
-                    if (this.writeDelayMicroseconds) {
-                        this.rp2040.clock.createTimer(this.writeDelayMicroseconds, () => {
-                            var _a;
-                            (_a = this.onEndpointWrite) === null || _a === void 0 ? void 0 : _a.call(this, endpoint, buffer);
-                        });
-                    }
-                    else {
-                        (_d = this.onEndpointWrite) === null || _d === void 0 ? void 0 : _d.call(this, endpoint, buffer);
-                    }
+                    this.endpointWriteAlarms[endpoint].schedule(buffer, this.writeDelayMicroseconds * 1000);
                 }
             }
+            const bufferLength = value & USB_BUF_CTRL_LEN_MASK;
+            const bufferOffset = this.getEndpointBufferOffset(endpoint, bufferOut);
+            this.debug(`Start USB transfer, endPoint=${endpoint}, direction=${bufferOut ? 'out' : 'in'} buffer=${bufferOffset.toString(16)} length=${bufferLength}`);
+            value &= ~USB_BUF_CTRL_AVAILABLE;
+            this.rp2040.usbDPRAMView.setUint32(offset, value, true);
+            if (bufferOut) {
+                (_b = this.onEndpointRead) === null || _b === void 0 ? void 0 : _b.call(this, endpoint, bufferLength);
+            }
+            else {
+                value &= ~USB_BUF_CTRL_FULL;
+                this.rp2040.usbDPRAMView.setUint32(offset, value, true);
+                const buffer = this.rp2040.usbDPRAM.slice(bufferOffset, bufferOffset + bufferLength);
+                if (interrupt || !doubleBuffer) {
+                    this.indicateBufferReady(endpoint, false);
+                }
+                this.endpointWriteAlarms[endpoint].schedule(buffer, this.writeDelayMicroseconds * 1000);
+            }
         }
     }
     endpointReadDone(endpoint, buffer, delay = this.readDelayMicroseconds) {
-        if (delay) {
-            this.rp2040.clock.createTimer(delay, () => {
-                this.finishRead(endpoint, buffer);
-            });
-        }
-        else {
-            this.finishRead(endpoint, buffer);
-        }
+        this.endpointReadAlarms[endpoint].schedule(buffer, delay * 1000);
     }
     finishRead(endpoint, buffer) {
         const bufferOffset = this.getEndpointBufferOffset(endpoint, true);
@@ -256,8 +266,7 @@ export class RPUSBController extends BasePeripheral {
         this.rp2040.setInterrupt(IRQ.USBCTRL, !!intStatus);
     }
     resetDevice() {
-        this.sieStatus |= SIE_BUS_RESET;
-        this.sieStatusUpdated();
+        this.resetAlarm.schedule(10000000); // USB reset takes ~10ms
     }
     sendSetupPacket(setupPacket) {
         this.rp2040.usbDPRAM.set(setupPacket);

package/dist/esm/rp2040.d.ts

@@ -44,9 +44,7 @@ export declare class RP2040 {
     readonly pio: RPPIO[];
     readonly usbCtrl: RPUSBController;
     readonly spi: RPSPI[];
-    private stopped;
     logger: Logger;
-    private executeTimer;
     readonly peripherals: {
         [index: number]: Peripheral;
     };
@@ -66,7 +64,4 @@ export declare class RP2040 {
     setInterrupt(irq: number, value: boolean): void;
     updateIOInterrupt(): void;
     step(): void;
-    execute(): void;
-    stop(): void;
-    get executing(): boolean;
 }

package/dist/esm/rp2040.js

@@ -1,4 +1,4 @@
-import { RealtimeClock } from './clock/realtime-clock.js';
+import { SimulationClock } from './clock/simulation-clock.js';
 import { CortexM0Core } from './cortex-m0-core.js';
 import { GPIOPin } from './gpio-pin.js';
 import { IRQ } from './irq.js';
@@ -37,7 +37,7 @@ const KB = 1024;
 const MB = 1024 * KB;
 const MHz = 1000000;
 export class RP2040 {
-    constructor(clock = new RealtimeClock()) {
+    constructor(clock = new SimulationClock()) {
         this.clock = clock;
         this.bootrom = new Uint32Array(4 * KB);
         this.sram = new Uint8Array(264 * KB);
@@ -122,9 +122,7 @@ export class RP2040 {
                 tx: DREQChannel.DREQ_SPI1_TX,
             }),
         ];
-        this.stopped = true;
         this.logger = new ConsoleLogger(LogLevel.Debug, true);
-        this.executeTimer = null;
         this.peripherals = {
             0x18000: new RPSSI(this, 'SSI'),
             0x40000: new RP2040SysInfo(this, 'SYSINFO_BASE'),
@@ -164,7 +162,6 @@ export class RP2040 {
         this.onBreak = (code) => {
             // TODO: raise HardFault exception
             // console.error('Breakpoint!', code);
-            this.stopped = true;
         };
         this.reset();
     }
@@ -339,26 +336,4 @@ export class RP2040 {
     step() {
         this.core.executeInstruction();
     }
-    execute() {
-        this.clock.resume();
-        this.executeTimer = null;
-        this.stopped = false;
-        for (let i = 0; i < 100000 && !this.stopped && !this.core.waiting; i++) {
-            this.core.executeInstruction();
-        }
-        if (!this.stopped) {
-            this.executeTimer = setTimeout(() => this.execute(), 0);
-        }
-    }
-    stop() {
-        this.stopped = true;
-        if (this.executeTimer != null) {
-            clearTimeout(this.executeTimer);
-            this.executeTimer = null;
-        }
-        this.clock.pause();
-    }
-    get executing() {
-        return !this.stopped;
-    }
 }

package/dist/esm/simulator.d.ts

@@ -0,0 +1,13 @@
+import { SimulationClock } from './clock/simulation-clock.js';
+import { IGDBTarget } from './gdb/gdb-target.js';
+import { RP2040 } from './rp2040.js';
+export declare class Simulator implements IGDBTarget {
+    readonly clock: SimulationClock;
+    executeTimer: ReturnType<typeof setTimeout> | null;
+    rp2040: RP2040;
+    stopped: boolean;
+    constructor(clock?: SimulationClock);
+    execute(): void;
+    stop(): void;
+    get executing(): boolean;
+}

package/dist/esm/simulator.js

@@ -0,0 +1,41 @@
+import { SimulationClock } from './clock/simulation-clock.js';
+import { RP2040 } from './rp2040.js';
+export class Simulator {
+    constructor(clock = new SimulationClock()) {
+        this.clock = clock;
+        this.executeTimer = null;
+        this.stopped = true;
+        this.rp2040 = new RP2040(clock);
+        this.rp2040.onBreak = () => this.stop();
+    }
+    execute() {
+        const { rp2040, clock } = this;
+        this.executeTimer = null;
+        this.stopped = false;
+        const cycleNanos = 1e9 / 125000000; // 125 MHz
+        for (let i = 0; i < 1000000 && !this.stopped; i++) {
+            if (rp2040.core.waiting) {
+                const { nanosToNextAlarm } = clock;
+                clock.tick(nanosToNextAlarm);
+                i += nanosToNextAlarm / cycleNanos;
+            }
+            else {
+                const cycles = rp2040.core.executeInstruction();
+                clock.tick(cycles * cycleNanos);
+            }
+        }
+        if (!this.stopped) {
+            this.executeTimer = setTimeout(() => this.execute(), 0);
+        }
+    }
+    stop() {
+        this.stopped = true;
+        if (this.executeTimer != null) {
+            clearTimeout(this.executeTimer);
+            this.executeTimer = null;
+        }
+    }
+    get executing() {
+        return !this.stopped;
+    }
+}

package/dist/esm/utils/timer32.d.ts

@@ -8,7 +8,7 @@ export declare class Timer32 {
     readonly clock: IClock;
     private baseFreq;
     private baseValue;
-    private baseMicros;
+    private baseNanos;
     private topValue;
     private prescalerValue;
     private timerMode;
@@ -32,7 +32,7 @@ export declare class Timer32 {
     set frequency(value: number);
     get prescaler(): number;
     set prescaler(value: number);
-    toMicros(cycles: number): number;
+    toNanos(cycles: number): number;
     get enable(): boolean;
     set enable(value: boolean);
     get mode(): TimerMode;
@@ -44,7 +44,7 @@ export declare class Timer32PeriodicAlarm {
     readonly callback: () => void;
     private targetValue;
     private enabled;
-    private clockTimer?;
+    private clockAlarm;
     constructor(timer: Timer32, callback: () => void);
     get enable(): boolean;
     set enable(value: boolean);

package/dist/esm/utils/timer32.js

@@ -9,7 +9,7 @@ export class Timer32 {
         this.clock = clock;
         this.baseFreq = baseFreq;
         this.baseValue = 0;
-        this.baseMicros = 0;
+        this.baseNanos = 0;
         this.topValue = 0xffffffff;
         this.prescalerValue = 1;
         this.timerMode = TimerMode.Increment;
@@ -17,13 +17,13 @@ export class Timer32 {
         this.listeners = [];
     }
     reset() {
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.baseValue = 0;
         this.updated();
     }
     set(value, zigZagDown = false) {
         this.baseValue = zigZagDown ? this.topValue * 2 - value : value;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.updated();
     }
     /**
@@ -36,12 +36,12 @@ export class Timer32 {
         this.baseValue += delta;
     }
     get rawCounter() {
-        const { baseFreq, prescalerValue, baseMicros, baseValue, enabled, timerMode } = this;
+        const { baseFreq, prescalerValue, baseNanos, baseValue, enabled, timerMode } = this;
         if (!baseFreq || !prescalerValue || !enabled) {
             return this.baseValue;
         }
         const zigzag = timerMode == TimerMode.ZigZag;
-        const ticks = ((this.clock.micros - baseMicros) / 1e6) * (baseFreq / prescalerValue);
+        const ticks = ((this.clock.nanos - baseNanos) / 1e9) * (baseFreq / prescalerValue);
         const topModulo = zigzag ? this.topValue * 2 : this.topValue + 1;
         const delta = timerMode == TimerMode.Decrement ? topModulo - (ticks % topModulo) : ticks;
         let currentValue = Math.round(baseValue + delta);
@@ -70,7 +70,7 @@ export class Timer32 {
     }
     set frequency(value) {
         this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.baseFreq = value;
         this.updated();
     }
@@ -79,14 +79,14 @@ export class Timer32 {
     }
     set prescaler(value) {
         this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.enabled = this.prescalerValue !== 0;
         this.prescalerValue = value;
         this.updated();
     }
-    toMicros(cycles) {
+    toNanos(cycles) {
         const { baseFreq, prescalerValue } = this;
-        return (cycles * 1e6) / (baseFreq / prescalerValue);
+        return (cycles * 1e9) / (baseFreq / prescalerValue);
     }
     get enable() {
         return this.enabled;
@@ -94,7 +94,7 @@ export class Timer32 {
     set enable(value) {
         if (value !== this.enabled) {
             if (value) {
-                this.baseMicros = this.clock.micros;
+                this.baseNanos = this.clock.nanos;
             }
             else {
                 this.baseValue = this.counter;
@@ -137,6 +137,7 @@ export class Timer32PeriodicAlarm {
                 this.schedule();
             }
         };
+        this.clockAlarm = this.timer.clock.createAlarm(this.handleAlarm);
         timer.listeners.push(this.update);
     }
     get enable() {
@@ -191,13 +192,10 @@ export class Timer32PeriodicAlarm {
             cycleDelta = top + 1 - cycleDelta;
         }
         const cyclesToAlarm = cycleDelta >>> 0;
-        const microsToAlarm = timer.toMicros(cyclesToAlarm);
-        this.clockTimer = this.timer.clock.createTimer(microsToAlarm, this.handleAlarm);
+        const nanosToAlarm = timer.toNanos(cyclesToAlarm);
+        this.clockAlarm.schedule(nanosToAlarm);
     }
     cancel() {
-        if (this.clockTimer) {
-            this.timer.clock.deleteTimer(this.clockTimer);
-            this.clockTimer = undefined;
-        }
+        this.clockAlarm.cancel();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rp2040js",
-  "version": "0.19.4",
+  "version": "1.0.1",
   "description": "Raspberry Pi Pico (RP2040) Emulator",
   "repository": "https://github.com/wokwi/rp2040js",
   "keywords": [

package/dist/cjs/clock/realtime-clock.d.ts

@@ -1,23 +0,0 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class ClockTimer implements IClockTimer {
-    private micros;
-    private callback;
-    private jsTimer;
-    private timeLeft;
-    constructor(micros: number, callback: () => void);
-    schedule(currentMicros: number): void;
-    unschedule(): void;
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export declare class RealtimeClock implements IClock {
-    baseTime: number;
-    pauseTime: number;
-    paused: boolean;
-    timers: Set<ClockTimer>;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): ClockTimer;
-    deleteTimer(timer: ClockTimer): void;
-    get micros(): number;
-}

package/dist/cjs/clock/realtime-clock.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RealtimeClock = exports.ClockTimer = void 0;
-const time_js_1 = require("../utils/time.js");
-class ClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-        this.jsTimer = null;
-        this.timeLeft = this.micros;
-    }
-    schedule(currentMicros) {
-        this.jsTimer = setTimeout(this.callback, (this.micros - currentMicros) / 1000);
-    }
-    unschedule() {
-        if (this.jsTimer) {
-            clearTimeout(this.jsTimer);
-            this.jsTimer = null;
-        }
-    }
-    pause(currentMicros) {
-        this.timeLeft = this.micros - currentMicros;
-        this.unschedule();
-    }
-    resume(currentMicros) {
-        this.micros = currentMicros + this.timeLeft;
-        this.schedule(currentMicros);
-    }
-}
-exports.ClockTimer = ClockTimer;
-class RealtimeClock {
-    constructor() {
-        this.baseTime = 0;
-        this.pauseTime = 0;
-        this.paused = true;
-        this.timers = new Set();
-    }
-    pause() {
-        if (!this.paused) {
-            for (const timer of this.timers) {
-                timer.pause(this.micros);
-            }
-            this.pauseTime = this.micros;
-            this.paused = true;
-        }
-    }
-    resume() {
-        if (this.paused) {
-            this.baseTime = (0, time_js_1.getCurrentMicroseconds)() - this.pauseTime;
-            this.paused = false;
-            for (const timer of this.timers) {
-                timer.resume(this.micros);
-            }
-        }
-    }
-    createTimer(deltaMicros, callback) {
-        const timer = new ClockTimer(this.micros + deltaMicros, () => {
-            this.timers.delete(timer);
-            callback();
-        });
-        timer.schedule(this.micros);
-        this.timers.add(timer);
-        return timer;
-    }
-    deleteTimer(timer) {
-        timer.unschedule();
-        this.timers.delete(timer);
-    }
-    get micros() {
-        return (0, time_js_1.getCurrentMicroseconds)() - this.baseTime;
-    }
-}
-exports.RealtimeClock = RealtimeClock;

package/dist/esm/clock/realtime-clock.d.ts

@@ -1,23 +0,0 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class ClockTimer implements IClockTimer {
-    private micros;
-    private callback;
-    private jsTimer;
-    private timeLeft;
-    constructor(micros: number, callback: () => void);
-    schedule(currentMicros: number): void;
-    unschedule(): void;
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export declare class RealtimeClock implements IClock {
-    baseTime: number;
-    pauseTime: number;
-    paused: boolean;
-    timers: Set<ClockTimer>;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): ClockTimer;
-    deleteTimer(timer: ClockTimer): void;
-    get micros(): number;
-}