@evolu/common 7.4.0 → 8.0.0-next.0

package/dist/src/Test.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Test utilities for deterministic testing.
+ *
+ * @module
+ */
+import { type TestConsoleDep } from "./Console.js";
+import { type RandomLibDep } from "./Random.js";
+import { type Run, type RunDeps } from "./Task.js";
+import { type Duration, type TestTimeDep } from "./Time.js";
+/**
+ * Cheap deterministic baseline deps for tests.
+ *
+ * `TestDeps` includes test-friendly replacements for {@link RunDeps}, such as
+ * {@link TestConsole} and {@link TestTime}, plus extra helpers commonly useful in
+ * tests and fixtures, such as `randomLib` (only that for now).
+ *
+ * Use it directly for synchronous test setup, fixtures, and helpers. It is also
+ * intentionally the base deps used by {@link testCreateRun}.
+ */
+export type TestDeps = Omit<RunDeps, "console" | "time"> & TestConsoleDep & TestTimeDep & RandomLibDep;
+/**
+ * Creates deterministic {@link TestDeps}.
+ *
+ * Each call creates fresh instances, so tests don't share state.
+ *
+ * Includes these deps:
+ *
+ * - `console`: {@link TestConsole}
+ * - `random`: {@link Random}
+ * - `randomLib`: seeded `random` package instance
+ * - `randomBytes`: {@link RandomBytes}
+ * - `time`: {@link TestTime}
+ *
+ * Use this for synchronous code that accepts deps directly. For tests that run
+ * Tasks, use {@link testCreateRun}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * test("Callbacks with no argument", () => {
+ *   const deps = testCreateDeps();
+ *   const callbacks = createCallbacks(deps);
+ *
+ *   let called = false;
+ *   const id = callbacks.register(() => {
+ *     called = true;
+ *   });
+ *
+ *   callbacks.execute(id);
+ *   expect(called).toBe(true);
+ * });
+ * ```
+ */
+export declare const testCreateDeps: (options?: {
+    readonly seed?: string;
+}) => TestDeps;
+/**
+ * Creates a test {@link Run} with deterministic default deps or optional custom
+ * deps.
+ *
+ * Use this as the default composition root in tests. Each call creates fresh
+ * {@link TestDeps} via {@link testCreateDeps}, then merges any provided custom
+ * deps.
+ *
+ * ### Example
+ *
+ * ```ts
+ * // Built-in TestTime
+ * await using run = testCreateRun();
+ * const fiber = run(sleep("1s"));
+ * run.deps.time.advance("1s");
+ * await fiber;
+ *
+ * // For a single test, create the dependency using the Run.
+ * await using run = testCreateRun();
+ * await using foo = await run.orThrow(createFoo());
+ * const runWithFoo = run.addDeps({ foo });
+ *
+ * expect(runWithFoo.deps.foo).toBe(foo);
+ *
+ * // If multiple tests need the same setup, create a disposable helper.
+ * // Then `await using setup` disposes everything the helper owns.
+ * const setupFoo = async () => {
+ *   await using stack = new AsyncDisposableStack();
+ *   const run = stack.use(testCreateRun());
+ *   const foo = stack.use(await run.orThrow(createFoo()));
+ *   const moved = stack.move();
+ *
+ *   // Return whatever the tests need: a Run with the dependency,
+ *   // the dependency itself, or both.
+ *   return {
+ *     run: run.addDeps({ foo }),
+ *     foo,
+ *     [Symbol.asyncDispose]: () => moved.disposeAsync(),
+ *   };
+ * };
+ *
+ * await using setup = await setupFoo();
+ * const { run, foo } = setup;
+ * expect(run.deps.foo).toBe(foo);
+ * ```
+ *
+ * Name reusable setup helpers after what they set up:
+ *
+ * - `setupFoo` for reusable test setup for `Foo`
+ * - `testSetupFoo` when a library module exports the helper as part of its public
+ *   test API, e.g. `testSetupSqlite`.
+ */
+export declare function testCreateRun(): Run<TestDeps>;
+/** With custom dependencies merged into {@link TestDeps}. */
+export declare function testCreateRun<D>(deps: D): Run<TestDeps & D>;
+/**
+ * Returns a Promise that resolves after a macrotask delay.
+ *
+ * Use this to model a real async boundary in a test double, for example an
+ * async disposer that should not complete in the same turn.
+ *
+ * Avoid using it to coordinate assertions. Waiting for a macrotask tends to
+ * make tests indirect and brittle.
+ */
+export declare const testWaitForMacrotask: (duration?: Duration) => Promise<void>;
+//# sourceMappingURL=Test.d.ts.map

package/dist/src/Test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Test.d.ts","sourceRoot":"","sources":["../../src/Test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAa,KAAK,GAAG,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAIL,KAAK,QAAQ,EAEb,KAAK,WAAW,EACjB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,GACtD,cAAc,GACd,WAAW,GACX,YAAY,CAAC;AAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,KAAG,QAQH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,aAAa,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;AAE/C,6DAA6D;AAC7D,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;AAO7D;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAC/B,WAAU,QAAoB,KAC7B,OAAO,CAAC,IAAI,CAAyB,CAAC"}

package/dist/src/Test.js

@@ -0,0 +1,66 @@
+/**
+ * Test utilities for deterministic testing.
+ *
+ * @module
+ */
+import { testCreateConsole, } from "./Console.js";
+import { testCreateRandomBytes } from "./Crypto.js";
+import { testCreateRandom, testCreateRandomLib, } from "./Random.js";
+import { createRun } from "./Task.js";
+import { minMillis, setTimeout, testCreateTime, } from "./Time.js";
+/**
+ * Creates deterministic {@link TestDeps}.
+ *
+ * Each call creates fresh instances, so tests don't share state.
+ *
+ * Includes these deps:
+ *
+ * - `console`: {@link TestConsole}
+ * - `random`: {@link Random}
+ * - `randomLib`: seeded `random` package instance
+ * - `randomBytes`: {@link RandomBytes}
+ * - `time`: {@link TestTime}
+ *
+ * Use this for synchronous code that accepts deps directly. For tests that run
+ * Tasks, use {@link testCreateRun}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * test("Callbacks with no argument", () => {
+ *   const deps = testCreateDeps();
+ *   const callbacks = createCallbacks(deps);
+ *
+ *   let called = false;
+ *   const id = callbacks.register(() => {
+ *     called = true;
+ *   });
+ *
+ *   callbacks.execute(id);
+ *   expect(called).toBe(true);
+ * });
+ * ```
+ */
+export const testCreateDeps = (options) => {
+    const seed = options?.seed ?? "evolu";
+    const console = testCreateConsole();
+    const random = testCreateRandom(seed);
+    const randomLib = testCreateRandomLib(seed);
+    const randomBytes = testCreateRandomBytes({ randomLib });
+    const time = testCreateTime();
+    return { console, randomBytes, random, randomLib, time };
+};
+export function testCreateRun(deps) {
+    const defaults = testCreateDeps();
+    return createRun({ ...defaults, ...deps });
+}
+/**
+ * Returns a Promise that resolves after a macrotask delay.
+ *
+ * Use this to model a real async boundary in a test double, for example an
+ * async disposer that should not complete in the same turn.
+ *
+ * Avoid using it to coordinate assertions. Waiting for a macrotask tends to
+ * make tests indirect and brittle.
+ */
+export const testWaitForMacrotask = (duration = minMillis) => setTimeout(duration);

package/dist/src/Time.d.ts

@@ -1,80 +1,233 @@
-import { DateIso, NonNegativeInt } from "./Type.js";
-/** Retrieves the current time in milliseconds, similar to `Date.now()`. */
+/**
+ * Time representations, durations, and scheduling utilities.
+ *
+ * @module
+ */
+import type { Brand } from "./Brand.js";
+import { type DateIso } from "./Type.js";
+import type { Digit, Digit1To23, Digit1To51, Digit1To59, Digit1To6, Digit1To9, Digit1To99 } from "./Types.js";
+/** Time and timer operations. */
 export interface Time {
-    readonly now: () => number;
-    readonly nowIso: () => DateIso;
+    /** Returns current time as Unix epoch milliseconds. */
+    readonly now: () => Millis;
+    /** Returns current time as an ISO 8601 UTC string. */
+    readonly nowDateIso: () => DateIso;
+    /** Schedules a callback after the specified delay. */
+    readonly setTimeout: (fn: () => void, delay: Duration) => TimeoutId;
+    /** Cancels a timeout scheduled with {@link Time.setTimeout}. */
+    readonly clearTimeout: (id: TimeoutId) => void;
 }
 export interface TimeDep {
     readonly time: Time;
 }
 /**
- * Creates a {@link Time} using Date.now().
+ * Opaque type for timeout handles.
  *
- * If the system clock is misconfigured (out of allowed range), the application
- * will fail with an assertion error. This is intentional - there's no
- * reasonable fallback when the system clock is fundamentally wrong.
+ * Use with {@link Time.clearTimeout} to cancel a pending timeout.
+ */
+export type TimeoutId = Brand<"TimeoutId">;
+/**
+ * Creates a {@link Time} using `Date.now()` and `globalThis.setTimeout`.
+ *
+ * Throws if the system clock returns an out-of-range value. This is intentional
+ * — there's no reasonable fallback for a misconfigured clock.
  */
 export declare const createTime: () => Time;
 /**
- * Creates a {@link Time} that returns a monotonically increasing number based on
- * a queueMicrotask.
+ * Test {@link Time} with controllable timers.
+ *
+ * Call `advance(ms)` to move time forward and trigger any pending timeouts.
  */
-export declare const createTestTime: () => Time;
-/** Single digit 0-9. Used internally for {@link DurationString} validation. */
-export type D = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+export interface TestTime extends Time {
+    /** Advances time by the specified duration, triggering pending timeouts. */
+    readonly advance: (duration: Duration) => void;
+}
+export interface TestTimeDep {
+    readonly time: TestTime;
+}
 /**
- * Minutes and seconds 1-59. Used internally for {@link DurationString}
- * validation. Uses single digits for 1-9, full numbers for 10-59.
+ * Creates a {@link TestTime} with controllable timers for testing.
+ *
+ * Time starts at `startAt` (default 0) and only advances when `advance()` is
+ * called. Timeouts scheduled via `setTimeout` fire when time is advanced past
+ * their deadline.
+ *
+ * Set `autoIncrement` to automatically increment time by 1ms after each `now()`
+ * call via microtask (useful for tests that need monotonically increasing
+ * values without explicit `advance()` calls).
  */
-export type MmSs = Exclude<D, "0"> | `1${D}` | `2${D}` | `3${D}` | `4${D}` | `5${D}`;
-/** Hours 1-23. Used internally for {@link DurationString} validation. */
-export type Hours = Exclude<D, "0"> | `1${D}` | `2${"0" | "1" | "2" | "3"}`;
-/** Days 1-99. Used internally for {@link DurationString} validation. */
-export type Days = Exclude<D, "0"> | `${Exclude<D, "0">}${D}`;
+export declare const testCreateTime: (options?: {
+    readonly startAt?: Millis;
+    readonly autoIncrement?: boolean;
+}) => TestTime;
 /**
- * Template literal type for compile-time validated duration strings.
+ * Milliseconds timestamp, like `Date.now()`.
+ *
+ * The maximum value is 281474976710654 (281474976710655 - 1, reserved for
+ * infinity). This enables efficient binary serialization, saving 2 bytes
+ * compared to typical 8-byte (64-bit) timestamps.
+ *
+ * `new Date(281474976710654).toString()` = Tue Aug 02 10889 07:31:49
  *
- * Allowed patterns: basic units (ms, s, m, h, d) and logical combinations
- * (s+ms, m+s, h+m, d+h).
+ * If a system clock exceeds this range, operations will throw. This is
+ * intentional — there's no reasonable fallback for a misconfigured clock.
+ */
+export declare const Millis: import("./Type.js").BrandType<import("./Type.js").BrandType<import("./Type.js").Type<"Brand", number & Brand<"Int"> & Brand<"NonNegative">, number, import("./Type.js").NonNegativeError, number & Brand<"Int">, import("./Type.js").NumberError | import("./Type.js").IntError>, "LessThan281474976710655", import("./Type.js").LessThanError<281474976710655>, import("./Type.js").NumberError | import("./Type.js").NonNegativeError | import("./Type.js").IntError>, "Millis", import("./Type.js").BrandWithoutRefineError<"Millis", import("./Type.js").NumberError | import("./Type.js").LessThanError<281474976710655> | import("./Type.js").NonNegativeError | import("./Type.js").IntError>, never>;
+export type Millis = typeof Millis.Type;
+/** Minimum {@link Millis} value. */
+export declare const minMillis: Millis;
+/** Maximum {@link Millis} value. */
+export declare const maxMillis: Millis;
+/**
+ * Converts {@link Millis} to {@link DateIso}.
+ *
+ * This is a safe cast because {@link Millis} guarantees a valid timestamp range
+ * that always produces a valid ISO string.
+ */
+export declare const millisToDateIso: (value: Millis) => DateIso;
+/**
+ * Duration can be either a {@link DurationLiteral} or milliseconds as
+ * {@link Millis}.
+ */
+export type Duration = DurationLiteral | Millis;
+/**
+ * Duration literal with compile-time validation.
  *
  * Supported formats:
  *
- * - Milliseconds: `0ms`, `1ms`, `500ms`, `999ms`
- * - Seconds: `5s`, `30s` (1-59, single digit for 1-9)
- * - Minutes: `5m`, `30m` (1-59, single digit for 1-9)
- * - Hours: `1h`, `12h`, `23h` (1-23)
- * - Days: `1d`, `30d`, `99d` (1-99)
- * - Combinations: `1s 250ms`, `30m 15s`, `2h 45m`, `7d 12h`
+ * - Milliseconds: `1ms`, `500ms`, `999ms` (1-999)
+ * - Seconds: `1s`, `59s`, `12.5s` (1-59, 1.1-59.9)
+ * - Minutes: `1m`, `59m`, `12.5m` (1-59, 1.1-59.9)
+ * - Hours: `1h`, `23h`, `12.5h` (1-23, 1.1-23.9)
+ * - Days: `1d`, `6d`, `1.5d` (1-6, 1.1-6.9)
+ * - Weeks: `1w`, `51w`, `1.5w` (1-51, 1.1-51.9)
+ * - Months: not supported (variable length)
+ * - Years: `1y`, `99y`, `1.5y` (1-99, 1.1-99.9)
+ *
+ * Each unit is limited to values that can't be expressed in the next larger
+ * unit, ensuring every duration has exactly one canonical representation (e.g.,
+ * 1000ms must be written as `"1s"`, not `"1000ms"`).
  *
- * Note: Duration strings are for developer experience only - they provide
- * readable, compile-time validated expressions but should never be persisted or
- * parsed from users as they are not localized. Always convert to NonNegativeInt
- * (milliseconds) for storage and APIs.
+ * Decimal values cover cases like 1.5s (1500ms) or 1.5h (90 minutes) without
+ * allowing redundant forms. For precise values that don't fit (e.g., 1050ms),
+ * use {@link Millis} directly.
+ *
+ * Zero duration (0ms) is not supported. For yielding without delay, use `await
+ * Promise.resolve()` for microtasks or the {@link yieldNow} for macrotasks.
+ *
+ * See {@link Duration} for a type that also accepts {@link Millis}. Use
+ * {@link durationToMillis} to convert to milliseconds.
+ */
+export type DurationLiteral = DurationLiteralMilliseconds | DurationLiteralSeconds | DurationLiteralMinutes | DurationLiteralHours | DurationLiteralDays | DurationLiteralWeeks | DurationLiteralYears;
+/** Milliseconds duration: `"1ms"` to `"999ms"`. See {@link DurationLiteral}. */
+export type DurationLiteralMilliseconds = `${Digit1To9}ms` | `${Digit1To9}${Digit}ms` | `${Digit1To9}${Digit}${Digit}ms`;
+/**
+ * Seconds duration: `"1s"` to `"59s"` or `"1.1s"` to `"59.9s"`. See
+ * {@link DurationLiteral}.
+ */
+export type DurationLiteralSeconds = `${Digit1To59}s` | `${Digit1To59}.${Digit1To9}s`;
+/**
+ * Minutes duration: `"1m"` to `"59m"` or `"1.1m"` to `"59.9m"`. See
+ * {@link DurationLiteral}.
+ */
+export type DurationLiteralMinutes = `${Digit1To59}m` | `${Digit1To59}.${Digit1To9}m`;
+/**
+ * Hours duration: `"1h"` to `"23h"` or `"1.1h"` to `"23.9h"`. See
+ * {@link DurationLiteral}.
+ */
+export type DurationLiteralHours = `${Digit1To23}h` | `${Digit1To23}.${Digit1To9}h`;
+/**
+ * Days duration: `"1d"` to `"6d"` or `"1.1d"` to `"6.9d"`. See
+ * {@link DurationLiteral}.
+ */
+export type DurationLiteralDays = `${Digit1To6}d` | `${Digit1To6}.${Digit1To9}d`;
+/**
+ * Weeks duration: `"1w"` to `"51w"` or `"1.1w"` to `"51.9w"`. See
+ * {@link DurationLiteral}.
  */
-export type DurationString = `${D}ms` | `${D}${D}ms` | `${D}${D}${D}ms` | `${MmSs}s` | `${MmSs}m` | `${Hours}h` | `${Days}d` | `${MmSs}s ${D}ms` | `${MmSs}s ${D}${D}ms` | `${MmSs}s ${D}${D}${D}ms` | `${MmSs}m ${MmSs}s` | `${Hours}h ${MmSs}m` | `${Days}d ${Hours}h`;
+export type DurationLiteralWeeks = `${Digit1To51}w` | `${Digit1To51}.${Digit1To9}w`;
 /**
- * Duration can be either a {@link DurationString} or milliseconds as
- * {@link NonNegativeInt}.
+ * Years duration: `"1y"` to `"99y"` or `"1.1y"` to `"99.9y"`. See
+ * {@link DurationLiteral}.
  */
-export type Duration = DurationString | NonNegativeInt;
+export type DurationLiteralYears = `${Digit1To99}y` | `${Digit1To99}.${Digit1To9}y`;
 /**
  * Converts a duration to milliseconds.
  *
- * Accepts either a {@link DurationString} (e.g., "5m", "1h 30m") or milliseconds
- * as {@link NonNegativeInt}.
+ * Accepts either a {@link DurationLiteral} (e.g., "5m", "1.5s") or
+ * {@link Millis}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * durationToMillis("1ms"); // 1
+ * durationToMillis("500ms"); // 500
+ * durationToMillis("1.5s"); // 1500
+ * durationToMillis("30s"); // 30000
+ * durationToMillis("5m"); // 300000
+ * durationToMillis("12h"); // 43200000
+ * durationToMillis("7d"); // 604800000
+ * durationToMillis(Millis.orThrow(5000)); // 5000 (already Millis)
+ * ```
+ */
+export declare const durationToMillis: (duration: Duration) => Millis;
+/**
+ * Returns a Promise that resolves after the specified duration.
+ *
+ * Uses {@link Duration} parsing and `globalThis.setTimeout`.
+ *
+ * ### Example
+ *
+ * ```ts
+ * await setTimeout("1ms");
+ * ```
+ */
+export declare const setTimeout: (duration: Duration) => Promise<void>;
+/**
+ * Frame budget at 60fps (16ms).
+ *
+ * Work exceeding this blocks a frame, causing visible jank in animations.
+ */
+export declare const ms60fps: Millis;
+/**
+ * Frame budget at 120fps (8ms).
+ *
+ * For high refresh rate displays. Work exceeding this blocks a frame.
+ */
+export declare const ms120fps: Millis;
+/**
+ * Long task threshold (50ms).
+ *
+ * Tasks exceeding this are "long tasks" per web standards. Use with
+ * {@link yieldNow} to yield periodically and keep UI responsive.
+ *
+ * @see https://web.dev/articles/optimize-long-tasks
+ */
+export declare const msLongTask: Millis;
+/**
+ * Formats {@link Millis} as a human-readable duration string.
+ *
+ * - Under 1 minute: `1.234s`
+ * - Under 1 hour: `1m30.000s`
+ * - 1 hour or more: `1h30m45.000s`
+ *
+ * ### Example
+ *
+ * ```ts
+ * formatMillisAsDuration(1234 as Millis); // "1.234s"
+ * formatMillisAsDuration(90000 as Millis); // "1m30.000s"
+ * formatMillisAsDuration(3661000 as Millis); // "1h1m1.000s"
+ * ```
+ */
+export declare const formatMillisAsDuration: (millis: Millis) => string;
+/**
+ * Formats {@link Millis} as `HH:MM:SS.mmm`.
  *
  * ### Example
  *
  * ```ts
- * durationToNonNegativeInt("0ms"); // 0 ✅
- * durationToNonNegativeInt("500ms"); // 500 ✅
- * durationToNonNegativeInt("30s"); // 30000 ✅
- * durationToNonNegativeInt("5m"); // 300000 ✅
- * durationToNonNegativeInt("12h"); // 43200000 ✅
- * durationToNonNegativeInt("7d"); // 604800000 ✅
- * durationToNonNegativeInt("2h 45m"); // 9900000 ✅
- * durationToNonNegativeInt(5000); // 5000 ✅ (already milliseconds)
+ * formatMillisAsClockTime(Millis.orThrow(Date.now())); // "14:32:15.234"
  * ```
  */
-export declare const durationToNonNegativeInt: (duration: Duration) => NonNegativeInt;
+export declare const formatMillisAsClockTime: (millis: Millis) => string;
 //# sourceMappingURL=Time.d.ts.map

package/dist/src/Time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../src/Time.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEpD,2EAA2E;AAC3E,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAO,IAa7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAO,IAcjC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE1E;;;GAGG;AACH,MAAM,MAAM,IAAI,GACZ,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,GACf,IAAI,CAAC,EAAE,GACP,IAAI,CAAC,EAAE,GACP,IAAI,CAAC,EAAE,GACP,IAAI,CAAC,EAAE,GACP,IAAI,CAAC,EAAE,CAAC;AAEZ,yEAAyE;AACzE,MAAM,MAAM,KAAK,GACb,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,GACf,IAAI,CAAC,EAAE,GACP,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;AAEhC,wEAAwE;AACxE,MAAM,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,cAAc,GACtB,GAAG,CAAC,IAAI,GACR,GAAG,CAAC,GAAG,CAAC,IAAI,GACZ,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAChB,GAAG,IAAI,GAAG,GACV,GAAG,IAAI,GAAG,GACV,GAAG,KAAK,GAAG,GACX,GAAG,IAAI,GAAG,GACV,GAAG,IAAI,KAAK,CAAC,IAAI,GACjB,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,GACrB,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GACzB,GAAG,IAAI,KAAK,IAAI,GAAG,GACnB,GAAG,KAAK,KAAK,IAAI,GAAG,GACpB,GAAG,IAAI,KAAK,KAAK,GAAG,CAAC;AAEzB;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,cAAc,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,QAAQ,KACjB,cA+DF,CAAC"}
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../src/Time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAS,KAAK,OAAO,EAA4B,MAAM,WAAW,CAAC;AAC1E,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,UAAU,EACV,UAAU,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,iCAAiC;AACjC,MAAM,WAAW,IAAI;IACnB,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAE3B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC;IAEnC,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC;IAEpE,gEAAgE;IAChE,QAAQ,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC;CAChD;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAO,IAkB7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,QAAS,SAAQ,IAAI;IACpC,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;CAChD;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,KAAG,QA2CH,CAAC;AAKF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,8qBAGlB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAC;AAExC,oCAAoC;AACpC,eAAO,MAAM,SAAS,EAAQ,MAAM,CAAC;AAErC,oCAAoC;AACpC,eAAO,MAAM,SAAS,EAAkC,MAAM,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,OACK,CAAC;AAEtD;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,eAAe,GAAG,MAAM,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,eAAe,GACvB,2BAA2B,GAC3B,sBAAsB,GACtB,sBAAsB,GACtB,oBAAoB,GACpB,mBAAmB,GACnB,oBAAoB,GACpB,oBAAoB,CAAC;AAEzB,gFAAgF;AAChF,MAAM,MAAM,2BAA2B,GACnC,GAAG,SAAS,IAAI,GAChB,GAAG,SAAS,GAAG,KAAK,IAAI,GACxB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,IAAI,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAC9B,GAAG,UAAU,GAAG,GAChB,GAAG,UAAU,IAAI,SAAS,GAAG,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAC9B,GAAG,UAAU,GAAG,GAChB,GAAG,UAAU,IAAI,SAAS,GAAG,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAC5B,GAAG,UAAU,GAAG,GAChB,GAAG,UAAU,IAAI,SAAS,GAAG,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B,GAAG,SAAS,GAAG,GACf,GAAG,SAAS,IAAI,SAAS,GAAG,CAAC;AAEjC;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAC5B,GAAG,UAAU,GAAG,GAChB,GAAG,UAAU,IAAI,SAAS,GAAG,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAC5B,GAAG,UAAU,GAAG,GAChB,GAAG,UAAU,IAAI,SAAS,GAAG,CAAC;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,QAAQ,KAAG,MAWrD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,UAAU,QAAQ,KAAG,OAAO,CAAC,IAAI,CAGxD,CAAC;AAYL;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAS,MAAM,CAAC;AAEpC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAQ,MAAM,CAAC;AAEpC;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAS,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,MAcvD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,QAAQ,MAAM,KAAG,MAOxD,CAAC"}