@evolu/common 8.5.0 → 8.6.0

package/dist/src/Array.js

@@ -16,13 +16,16 @@
  * to track:
  *
  * ```ts
- * const sortScores = (arr: number[]) => arr.sort((a, b) => a - b);
+ * import { assertEqual, assertSame } from "@evolu/common";
+ *
+ * // oxlint-disable-next-line unicorn/no-array-sort -- This example intentionally demonstrates mutating Array.sort.
+ * const sortScores = (arr: Array<number>) => arr.sort((a, b) => a - b);
  *
  * const scores = [3, 1, 2];
  * const leaderboard = sortScores(scores);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expect(scores).toEqual([1, 2, 3]);
- * expect(leaderboard).toBe(scores);
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertEqual(scores, [1, 2, 3]);
+ * assertSame(leaderboard, scores);
  * ```
  *
  * Imagine every method doing that.
@@ -31,30 +34,35 @@
  * instead:
  *
  * ```ts
- * import { sortArray } from "@evolu/common";
+ * import { assertEqual, assertTrue, sortArray } from "@evolu/common";
  *
  * const sortScores = (arr: ReadonlyArray<number>) =>
  *   sortArray(arr, (a, b) => a - b);
  *
  * const scores: ReadonlyArray<number> = [3, 1, 2];
  * const leaderboard = sortScores(scores);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expect(scores).toEqual([3, 1, 2]);
- * expect(leaderboard).not.toBe(scores);
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertEqual(scores, [3, 1, 2]);
+ * assertTrue(leaderboard !== scores);
  * ```
  *
  * Even better, require a {@link NonEmptyReadonlyArray} — there's nothing to sort
  * if the array is empty anyway:
  *
  * ```ts
- * import { sortArray, type NonEmptyReadonlyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   sortArray,
+ *   type NonEmptyReadonlyArray,
+ * } from "@evolu/common";
  *
  * const sortScores = (arr: NonEmptyReadonlyArray<number>) =>
  *   sortArray(arr, (a, b) => a - b);
  *
  * const leaderboard = sortScores([3, 1, 2]);
- * expect(leaderboard).toEqual([1, 2, 3]);
- * expectTypeOf(leaderboard).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(leaderboard, [1, 2, 3]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof leaderboard>();
  * ```
  *
  * Sorting an empty array isn't expensive, but functions can have side effects
@@ -68,13 +76,16 @@
  * readonly arrays without mutation — use them directly.
  *
  * ```ts
- * import { type NonEmptyReadonlyArray } from "@evolu/common";
+ * import { assertEqual, type NonEmptyReadonlyArray } from "@evolu/common";
  *
  * const valid: NonEmptyReadonlyArray<number> = [1, 2, 3];
  * // @ts-expect-error An empty array is not non-empty.
- * const invalid: NonEmptyReadonlyArray<number> = [];
+ * const _invalid: NonEmptyReadonlyArray<number> = [];
  *
- * expect(valid.find((value) => value === 2)).toBe(2);
+ * assertEqual(
+ *   valid.find((value) => value === 2),
+ *   2,
+ * );
  * ```
  *
  * ## Composition
@@ -83,7 +94,7 @@
  * because it's natural for single operations:
  *
  * ```ts
- * import { mapArray } from "@evolu/common";
+ * import { assertEqual, mapArray } from "@evolu/common";
  *
  * interface Message {
  *   readonly timestamp: number;
@@ -94,7 +105,7 @@
  *   { timestamp: 20 },
  * ];
  * const timestamps = mapArray(messages, (m) => m.timestamp);
- * expect(timestamps).toEqual([10, 20]);
+ * assertEqual(timestamps, [10, 20]);
  * ```
  *
  * Data-first style also reads well for a few operations, often fitting on a
@@ -102,6 +113,7 @@
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   dedupeArray,
  *   filterArray,
  *   firstInArray,
@@ -113,11 +125,11 @@
  * } from "@evolu/common";
  *
  * const cheapest = firstInArray(sortArray([30, 10, 20], orderNumber));
- * expect(cheapest).toBe(10);
+ * assertEqual(cheapest, 10);
  *
  * const users = [{ name: "Ada" }, { name: "Linus" }, { name: "Ada" }];
  * const uniqueNames = dedupeArray(mapArray(users, (u) => u.name));
- * expect(uniqueNames).toEqual(["Ada", "Linus"]);
+ * assertEqual(uniqueNames, ["Ada", "Linus"]);
  *
  * const jobs = [
  *   { id: 1, done: false },
@@ -127,7 +139,7 @@
  * if (!isNonEmptyArray(completedJobs)) throw new Error("Expected a job");
  * const latestDone = lastInArray(completedJobs);
  *
- * expect(latestDone).toEqual({ id: 2, done: true });
+ * assertEqual(latestDone, { id: 2, done: true });
  * ```
  *
  * For more operations, create a function like `getOldestActiveUser` or a
@@ -160,7 +172,11 @@ export const emptyArray = [];
  * ### Example
  *
  * ```ts
- * import { createMutableArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   createMutableArray,
+ * } from "@evolu/common";
  *
  * const values = createMutableArray<number>(3);
  *
@@ -168,8 +184,8 @@ export const emptyArray = [];
  *   values[index] = index * 10;
  * }
  *
- * expect(values).toEqual([0, 10, 20]);
- * expectTypeOf(values).toEqualTypeOf<Array<number>>();
+ * assertEqual(values, [0, 10, 20]);
+ * assertType<Array<number>, typeof values>();
  * ```
  *
  * @group Constructors
@@ -194,19 +210,24 @@ export function arrayFrom(iterableOrLength, map) {
  * ### Awaiting sync and async iterables
  *
  * ```ts
- * import { arrayFromAsync } from "@evolu/common";
+ * import { assertEqual, assertType, arrayFromAsync } from "@evolu/common";
  *
- * const fromIterable = await arrayFromAsync(new Set([1, 2, 3]));
- * expect(fromIterable).toEqual([1, 2, 3]);
+ * const fromIterable = await arrayFromAsync([
+ *   Promise.resolve(1),
+ *   Promise.resolve(2),
+ *   Promise.resolve(3),
+ * ]);
+ * assertEqual(fromIterable, [1, 2, 3]);
  *
  * const fromAsyncIterable = await arrayFromAsync(
- *   (async function* () {
- *     yield Promise.resolve(1);
- *     yield Promise.resolve(2);
+ *   (async function* (): AsyncGenerator<number> {
+ *     await Promise.resolve();
+ *     yield 1;
+ *     yield 2;
  *   })(),
  * );
- * expect(fromAsyncIterable).toEqual([1, 2]);
- * expectTypeOf(fromAsyncIterable).toEqualTypeOf<ReadonlyArray<number>>();
+ * assertEqual(fromAsyncIterable, [1, 2]);
+ * assertType<ReadonlyArray<number>, typeof fromAsyncIterable>();
  * ```
  *
  * Unlike `Array.fromAsync`, there's no map parameter — map the result with
@@ -227,13 +248,15 @@ export function isNonEmptyArray(array) {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   appendToArray,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values = appendToArray([1, 2, 3], 4);
- * expect(values).toEqual([1, 2, 3, 4]);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(values, [1, 2, 3, 4]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
  * ```
  *
  * @group Transformations
@@ -249,13 +272,15 @@ export const appendToArray = (array, item) =>
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   prependToArray,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values = prependToArray([2, 3], 1);
- * expect(values).toEqual([1, 2, 3]);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
+ * assertEqual(values, [1, 2, 3]);
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
  * ```
  *
  * @group Transformations
@@ -313,12 +338,12 @@ export function reverseArray(array) {
  * ### Removing and replacing values
  *
  * ```ts
- * import { spliceArray } from "@evolu/common";
+ * import { assertEqual, spliceArray } from "@evolu/common";
  *
  * const values: ReadonlyArray<number> = [1, 2, 3, 4];
- * expect(spliceArray(values, 1, 2)).toEqual([1, 4]);
- * expect(spliceArray([1, 2, 3], 1, 1, 10, 11)).toEqual([1, 10, 11, 3]);
- * expect(values).toEqual([1, 2, 3, 4]);
+ * assertEqual(spliceArray(values, 1, 2), [1, 4]);
+ * assertEqual(spliceArray([1, 2, 3], 1, 1, 10, 11), [1, 10, 11, 3]);
+ * assertEqual(values, [1, 2, 3, 4]);
  * ```
  *
  * @group Transformations
@@ -340,9 +365,9 @@ export function zipArray(arrays) {
  * ### Reading the first value
  *
  * ```ts
- * import { firstInArray } from "@evolu/common";
+ * import { assertEqual, firstInArray } from "@evolu/common";
  *
- * expect(firstInArray(["a", "b", "c"])).toBe("a");
+ * assertEqual(firstInArray(["a", "b", "c"]), "a");
  * ```
  *
  * @group Accessors
@@ -354,9 +379,9 @@ export const firstInArray = (array) => array[0];
  * ### Reading the last value
  *
  * ```ts
- * import { lastInArray } from "@evolu/common";
+ * import { assertEqual, lastInArray } from "@evolu/common";
  *
- * expect(lastInArray(["a", "b", "c"])).toBe("c");
+ * assertEqual(lastInArray(["a", "b", "c"]), "c");
  * ```
  *
  * @group Accessors

package/dist/src/Assert.d.ts

@@ -1,9 +1,13 @@
 /**
- * Runtime assertions for invariant checking.
+ * Runtime assertions for invariants and value checks.
  *
  * @module
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts";
+import { type Eq } from "./Eq.ts";
+import type { Err, InferErr, InferOk, Ok, Result } from "./Result.ts";
+import type { IsData } from "./Type.ts";
+import type { CompileTimeError } from "./Types.ts";
 /**
  * Ensures a condition is true, throwing an error with the provided message if
  * not.
@@ -18,15 +22,177 @@ import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts";
  * ### Example
  *
  * ```ts
- * import { assert as assertInvariant } from "@evolu/common";
+ * import { assert, assertEqual, assertErr, trySync } from "@evolu/common";
  *
- * expect(() => assertInvariant(true, "Expected true.")).not.toThrow();
- * expect(() => assertInvariant(false, "Expected true.")).toThrow(
- *   "Expected true.",
- * );
+ * assert(true, "Expected true.");
+ * const result = trySync(() => assert(false, "Expected true."));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected true.");
  * ```
  */
 export declare const assert: (condition: unknown, message: string) => asserts condition;
+/**
+ * Asserts that two values are the same according to {@link eqStrict}.
+ *
+ * `eqStrict` uses SameValue equality: it considers `NaN` the same as itself,
+ * distinguishes `0` from `-0`, and compares objects by reference identity.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertSame, assertType } from "@evolu/common";
+ *
+ * interface User {
+ *   readonly name: string;
+ * }
+ *
+ * const user: User = { name: "Ada" };
+ * const value: unknown = user;
+ *
+ * assertSame(value, user);
+ * assertType<User, typeof value>();
+ * ```
+ */
+export declare const assertSame: <Expected>(actual: unknown, expected: Expected) => asserts actual is Expected;
+/**
+ * Asserts that a value is exactly `true` and narrows it to `true`.
+ *
+ * Unlike {@link assert}, this checks an exact boolean value instead of
+ * truthiness and does not require a custom message.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertTrue, assertType } from "@evolu/common";
+ *
+ * const value: unknown = true;
+ * assertTrue(value);
+ * assertType<true, typeof value>();
+ * ```
+ */
+export declare const assertTrue: (value: unknown) => asserts value is true;
+/**
+ * Asserts that a value is exactly `false` and narrows it to `false`.
+ *
+ * Unlike {@link assert}, this checks an exact boolean value instead of falsiness
+ * and does not require a custom message.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertFalse, assertType } from "@evolu/common";
+ *
+ * const value: unknown = false;
+ * assertFalse(value);
+ * assertType<false, typeof value>();
+ * ```
+ */
+export declare const assertFalse: (value: unknown) => asserts value is false;
+/**
+ * Asserts that two {@link Data} values are equal according to {@link eqData}.
+ *
+ * Use this for concise value checks in platform-independent examples. Use
+ * {@link assert} with a descriptive message for application invariants.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual } from "@evolu/common";
+ *
+ * const actual = new Map([["roles", new Set(["admin", "author"])]]);
+ * const expected = new Map([["roles", new Set(["author", "admin"])]]);
+ *
+ * assertEqual(actual, expected);
+ * ```
+ */
+export declare function assertEqual<Actual, Expected>(actual: Actual, expected: Expected, ...dataError: AssertEqualError<Actual | Expected>): void;
+type AssertEqualError<Value> = IsData<Value> extends true ? [] : [
+    error: CompileTimeError<"assertEqual", "Actual and expected values must consist only of Data.">
+];
+/**
+ * Asserts that a {@link Result} is an {@link Ok}, optionally compares its value,
+ * and narrows the Result.
+ *
+ * With only a Result, this checks the variant without inspecting the value.
+ * When an expected value is provided, it uses {@link eqData}; its Data type is
+ * inferred independently, so an unbranded literal can compare a branded
+ * primitive or collection. Pass a custom {@link Eq} when either value is outside
+ * {@link Data} or needs domain-specific equality.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Ok,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
+ *
+ * interface User {
+ *   readonly id: string;
+ * }
+ *
+ * interface UserNotFoundError extends Typed<"UserNotFound"> {}
+ *
+ * const result: Result<User, UserNotFoundError> = ok({ id: "user-1" });
+ *
+ * assertOk(result);
+ * assertType<Ok<User>, typeof result>();
+ * assertEqual(result.value.id, "user-1");
+ * ```
+ */
+export declare function assertOk<R extends Result<unknown, unknown>>(result: R): asserts result is Extract<R, Ok<unknown>>;
+export declare function assertOk<R extends Result<unknown, unknown>>(result: R, expectedValue: InferOk<R>, eq: Eq<InferOk<R>>): asserts result is Extract<R, Ok<unknown>>;
+export declare function assertOk<R extends Result<unknown, unknown>, ExpectedValue>(result: R, ...comparison: [expectedValue: ExpectedValue] & (IsData<InferOk<R> | ExpectedValue> extends true ? unknown : {
+    readonly [Error in CompileTimeError<"assertOk", "Result value and expected value must consist only of Data when no custom Eq is provided.">]: never;
+})): asserts result is Extract<R, Ok<unknown>>;
+/**
+ * Asserts that a {@link Result} is an {@link Err}, optionally compares its error,
+ * and narrows the Result.
+ *
+ * With only a Result, this checks the variant without inspecting the error.
+ * When an expected error is provided, it uses {@link eqData}; its Data type is
+ * inferred independently, so an unbranded literal can compare a branded
+ * primitive or collection. Pass a custom {@link Eq} when either value is outside
+ * {@link Data} or needs domain-specific equality.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertType,
+ *   err,
+ *   type Err,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
+ *
+ * interface UserNotFoundError extends Typed<"UserNotFound"> {
+ *   readonly id: string;
+ * }
+ *
+ * const result: Result<string, UserNotFoundError> = err({
+ *   type: "UserNotFound",
+ *   id: "user-1",
+ * });
+ *
+ * assertErr(result);
+ * assertType<Err<UserNotFoundError>, typeof result>();
+ * assertEqual(result.error.id, "user-1");
+ * ```
+ */
+export declare function assertErr<R extends Result<unknown, unknown>>(result: R): asserts result is Extract<R, Err<unknown>>;
+export declare function assertErr<R extends Result<unknown, unknown>>(result: R, expectedError: InferErr<R>, eq: Eq<InferErr<R>>): asserts result is Extract<R, Err<unknown>>;
+export declare function assertErr<R extends Result<unknown, unknown>, ExpectedError>(result: R, ...comparison: [expectedError: ExpectedError] & (IsData<InferErr<R> | ExpectedError> extends true ? unknown : {
+    readonly [Error in CompileTimeError<"assertErr", "Result error and expected error must consist only of Data when no custom Eq is provided.">]: never;
+})): asserts result is Extract<R, Err<unknown>>;
 /**
  * Asserts that a value is non-nullable.
  *
@@ -44,15 +210,23 @@ export declare const assertNonNullable: <T>(value: T, message?: string) => asser
  * ### Example
  *
  * ```ts
- * import { assertNotNull } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotNull,
+ *   assertType,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * const value = undefined as string | null | undefined;
  * assertNotNull(value);
- * expectTypeOf(value).toEqualTypeOf<string | undefined>();
- * expect(value).toBeUndefined();
- * expect(() => assertNotNull(null)).toThrow(
- *   "Expected value not to be null.",
- * );
+ * assertType<string | undefined, typeof value>();
+ * assertEqual(value, undefined);
+ * const result = trySync(() => assertNotNull(null));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected value not to be null.");
  * ```
  */
 export declare const assertNotNull: <T>(value: T, message?: string) => asserts value is T & ({} | undefined);
@@ -65,15 +239,23 @@ export declare const assertNotNull: <T>(value: T, message?: string) => asserts v
  * ### Example
  *
  * ```ts
- * import { assertNotUndefined } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotUndefined,
+ *   assertType,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * const value = null as string | null | undefined;
  * assertNotUndefined(value);
- * expectTypeOf(value).toEqualTypeOf<string | null>();
- * expect(value).toBeNull();
- * expect(() => assertNotUndefined(undefined)).toThrow(
- *   "Expected value not to be undefined.",
- * );
+ * assertType<string | null, typeof value>();
+ * assertEqual(value, null);
+ * const result = trySync(() => assertNotUndefined(undefined));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Expected value not to be undefined.");
  * ```
  */
 export declare const assertNotUndefined: <T>(value: T, message?: string) => asserts value is T & ({} | null);
@@ -86,13 +268,21 @@ export declare const assertNotUndefined: <T>(value: T, message?: string) => asse
  * ### Example
  *
  * ```ts
- * import { assertNonEmptyArray, type NonEmptyArray } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertNonEmptyArray,
+ *   assertType,
+ *   trySync,
+ *   type NonEmptyArray,
+ * } from "@evolu/common";
  *
  * const values = [1, 2, 3];
  * assertNonEmptyArray(values);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyArray<number>>();
- * expect(values[0]).toBe(1);
- * expect(() => assertNonEmptyArray([])).toThrow();
+ * assertType<NonEmptyArray<number>, typeof values>();
+ * assertEqual(values[0], 1);
+ * const result = trySync(() => assertNonEmptyArray([]));
+ * assertErr(result);
  * ```
  */
 export declare const assertNonEmptyArray: <T>(arr: Array<T>, message?: string) => asserts arr is NonEmptyArray<T>;
@@ -106,15 +296,20 @@ export declare const assertNonEmptyArray: <T>(arr: Array<T>, message?: string) =
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
  *   assertNonEmptyReadonlyArray,
+ *   assertType,
+ *   trySync,
  *   type NonEmptyReadonlyArray,
  * } from "@evolu/common";
  *
  * const values: ReadonlyArray<number> = [1, 2, 3];
  * assertNonEmptyReadonlyArray(values);
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlyArray<number>>();
- * expect(values[0]).toBe(1);
- * expect(() => assertNonEmptyReadonlyArray([])).toThrow();
+ * assertType<NonEmptyReadonlyArray<number>, typeof values>();
+ * assertEqual(values[0], 1);
+ * const result = trySync(() => assertNonEmptyReadonlyArray([]));
+ * assertErr(result);
  * ```
  */
 export declare const assertNonEmptyReadonlyArray: <T>(arr: ReadonlyArray<T>, message?: string) => asserts arr is NonEmptyReadonlyArray<T>;
@@ -126,14 +321,21 @@ export declare const assertNonEmptyReadonlyArray: <T>(arr: ReadonlyArray<T>, mes
  * ### Example
  *
  * ```ts
- * import { assertNotDisposed } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertEqual,
+ *   assertErr,
+ *   assertNotDisposed,
+ *   trySync,
+ * } from "@evolu/common";
  *
  * await using disposer = new globalThis.AsyncDisposableStack();
- * expect(() => assertNotDisposed(disposer)).not.toThrow();
+ * assertNotDisposed(disposer);
  * await disposer.disposeAsync();
- * expect(() => assertNotDisposed(disposer)).toThrow(
- *   "Cannot use a disposed object.",
- * );
+ * const result = trySync(() => assertNotDisposed(disposer));
+ * assertErr(result);
+ * assert(result.error instanceof Error, "Expected an Error.");
+ * assertEqual(result.error.message, "Cannot use a disposed object.");
  * ```
  *
  * This is the JavaScript equivalent of the .NET `ObjectDisposedException`
@@ -144,4 +346,5 @@ export declare const assertNonEmptyReadonlyArray: <T>(arr: ReadonlyArray<T>, mes
 export declare const assertNotDisposed: (value: DisposableStack | AsyncDisposableStack | {
     readonly disposed: boolean;
 }) => void;
+export {};
 //# sourceMappingURL=Assert.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Assert.d.ts","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,EAAE,CACnB,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,SAKZ,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAKlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,EAC5B,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,CAKxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAKnC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAClC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EACb,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,aAAa,CAAC,CAAC,CAKlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,EAC1C,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EACrB,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,GAAG,IAAI,qBAAqB,CAAC,CAAC,CAK1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,UAE1B,eAAe,GAAG,oBAAoB,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,KACxE,IAEF,CAAC"}
+{"version":3,"file":"Assert.d.ts","sourceRoot":"","sources":["../../src/Assert.ts"],"names":[],"mappings":"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"}