@evolu/common 8.5.0 → 8.6.0

package/src/Types.ts

@@ -12,7 +12,12 @@
  * ### Completion callbacks
  *
  * ```ts
- * import { ok, type Callback, type Result } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   ok,
+ *   type Callback,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const completedValues: Array<string> = [];
  * const onComplete: Callback<string> = (value) => {
@@ -26,7 +31,7 @@
  * onComplete("direct");
  * for (const callback of queue) callback(ok("queued"));
  *
- * expect(completedValues).toEqual(["direct", "queued"]);
+ * assertEqual(completedValues, ["direct", "queued"]);
  * ```
  */
 export type Callback<T> = (value: T) => void;
@@ -39,7 +44,7 @@ export type Callback<T> = (value: T) => void;
  * ### Subscription teardown
  *
  * ```ts
- * import type { CallbackWithTeardown } from "@evolu/common";
+ * import { assertEqual, type CallbackWithTeardown } from "@evolu/common";
  *
  * interface EventSource {
  *   readonly start: () => void;
@@ -48,8 +53,12 @@ export type Callback<T> = (value: T) => void;
  *
  * const events: Array<string> = [];
  * const source: EventSource = {
- *   start: () => events.push("started"),
- *   stop: () => events.push("stopped"),
+ *   start: () => {
+ *     events.push("started");
+ *   },
+ *   stop: () => {
+ *     events.push("stopped");
+ *   },
  * };
  * const subscribe: CallbackWithTeardown<EventSource> = (source) => {
  *   source.start();
@@ -58,7 +67,7 @@ export type Callback<T> = (value: T) => void;
  * const teardown = subscribe(source);
  * if (teardown) teardown();
  *
- * expect(events).toEqual(["started", "stopped"]);
+ * assertEqual(events, ["started", "stopped"]);
  * ```
  */
 export type CallbackWithTeardown<T> = (value: T) => void | (() => void);
@@ -71,11 +80,11 @@ export type CallbackWithTeardown<T> = (value: T) => void | (() => void);
  * ### Filtering values
  *
  * ```ts
- * import type { Predicate } from "@evolu/common";
+ * import { assertEqual, type Predicate } from "@evolu/common";
  *
  * const isEven: Predicate<number> = (n) => n % 2 === 0;
  *
- * expect([1, 2, 3, 4].filter(isEven)).toEqual([2, 4]);
+ * assertEqual([1, 2, 3, 4].filter(isEven), [2, 4]);
  * ```
  */
 export type Predicate<T> = (value: T) => boolean;
@@ -88,12 +97,12 @@ export type Predicate<T> = (value: T) => boolean;
  * ### Filtering by position
  *
  * ```ts
- * import type { PredicateWithIndex } from "@evolu/common";
+ * import { assertEqual, type PredicateWithIndex } from "@evolu/common";
  *
- * const isEvenIndex: PredicateWithIndex<string> = (value, index) =>
+ * const isEvenIndex: PredicateWithIndex<string> = (_value, index) =>
  *   index % 2 === 0;
  *
- * expect(["a", "b", "c", "d"].filter(isEvenIndex)).toEqual(["a", "c"]);
+ * assertEqual(["a", "b", "c", "d"].filter(isEvenIndex), ["a", "c"]);
  * ```
  */
 export type PredicateWithIndex<T> = (value: T, index: number) => boolean;
@@ -104,7 +113,7 @@ export type PredicateWithIndex<T> = (value: T, index: number) => boolean;
  * ### Narrowing a value
  *
  * ```ts
- * import type { Refinement } from "@evolu/common";
+ * import { assert, assertEqual, type Refinement } from "@evolu/common";
  *
  * interface Animal {
  *   readonly name: string;
@@ -117,9 +126,9 @@ export type PredicateWithIndex<T> = (value: T, index: number) => boolean;
  *   "breed" in animal;
  * const dog: Dog = { name: "Dog", breed: "Beagle" };
  * const animal: Animal = dog;
- * if (!isDog(animal)) throw new Error("Expected a dog");
+ * assert(isDog(animal), "Expected a dog.");
  *
- * expect(animal.breed).toBe("Beagle");
+ * assertEqual(animal.breed, "Beagle");
  * ```
  */
 export type Refinement<in A, out B extends A> = (a: A) => a is B;
@@ -134,7 +143,12 @@ export type Refinement<in A, out B extends A> = (a: A) => a is B;
  * ### Indexed refinement
  *
  * ```ts
- * import { partitionArray, type RefinementWithIndex } from "@evolu/common";
+ * import {
+ *   assertTrue,
+ *   assertType,
+ *   partitionArray,
+ *   type RefinementWithIndex,
+ * } from "@evolu/common";
  *
  * type Item = {
  *   readonly type: "number" | "string";
@@ -152,9 +166,9 @@ export type Refinement<in A, out B extends A> = (a: A) => a is B;
  * ];
  * const [numbers, others] = partitionArray(items, isNumberItem);
  *
- * expectTypeOf(numbers).toEqualTypeOf<ReadonlyArray<NumberItem>>();
- * expect(numbers[0]?.value).toBe(2);
- * expect(others[0]?.value).toBe(1);
+ * assertType<ReadonlyArray<NumberItem>, typeof numbers>();
+ * assertTrue(numbers[0]?.value === 2);
+ * assertTrue(others[0]?.value === 1);
  * ```
  */
 export type RefinementWithIndex<in A, out B extends A> = (
@@ -177,7 +191,7 @@ export type RefinementWithIndex<in A, out B extends A> = (
  * ### Adding runtime identity
  *
  * ```ts
- * import { instance, type Instance } from "@evolu/common";
+ * import { assertEqual, instance, type Instance } from "@evolu/common";
  *
  * interface Foo extends Instance<"Foo"> {
  *   readonly value: string;
@@ -188,7 +202,7 @@ export type RefinementWithIndex<in A, out B extends A> = (
  *   value: "value",
  * };
  *
- * expect(foo["~evolu/instance"]).toBe("Foo");
+ * assertEqual(foo["~evolu/instance"], "Foo");
  * ```
  */
 export interface Instance<Name extends string> {
@@ -212,7 +226,12 @@ export const instance = <const Name extends string>(
  * ### Checking runtime identity
  *
  * ```ts
- * import { instance, isInstance, type Instance } from "@evolu/common";
+ * import {
+ *   assertTrue,
+ *   instance,
+ *   isInstance,
+ *   type Instance,
+ * } from "@evolu/common";
  *
  * interface Foo extends Instance<"Foo"> {
  *   readonly value: string;
@@ -221,7 +240,7 @@ export const instance = <const Name extends string>(
  * const isFoo = isInstance<Foo>("Foo");
  * const value: unknown = { ...instance("Foo"), value: "value" };
  *
- * expect(isFoo(value)).toBe(true);
+ * assertTrue(isFoo(value));
  * ```
  */
 export const isInstance =
@@ -241,17 +260,20 @@ export const isInstance =
  * ### Optional nullable properties
  *
  * ```ts
- * import type { NullablePartial } from "@evolu/common";
+ * import { assertType, type NullablePartial } from "@evolu/common";
  *
  * type Example = {
  *   required: string;
  *   optionalWithNull: string | null;
  * };
  *
- * expectTypeOf<NullablePartial<Example>>().toEqualTypeOf<{
- *   required: string;
- *   optionalWithNull?: string | null;
- * }>();
+ * assertType<
+ *   {
+ *     required: string;
+ *     optionalWithNull?: string | null;
+ *   },
+ *   NullablePartial<Example>
+ * >();
  * ```
  */
 export type NullablePartial<
@@ -308,15 +330,18 @@ export type Writable<T> = {
  * ### Flattening an intersection
  *
  * ```ts
- * import type { Simplify } from "@evolu/common";
+ * import { assertType, type Simplify } from "@evolu/common";
  *
  * type A = { a: string } & { b: number };
  * type B = Simplify<A>;
  *
- * expectTypeOf<B>().toEqualTypeOf<{
- *   a: string;
- *   b: number;
- * }>();
+ * assertType<
+ *   {
+ *     a: string;
+ *     b: number;
+ *   },
+ *   B
+ * >();
  * ```
  */
 export type Simplify<T> = {
@@ -339,7 +364,11 @@ export type PartialProp<T, K extends keyof T> = Omit<T, K> &
  * ### Sync and async completion
  *
  * ```ts
- * import { isPromiseLike, type Awaitable } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   isPromiseLike,
+ *   type Awaitable,
+ * } from "@evolu/common";
  *
  * const cache = new Map([["cached", "from cache"]]);
  * const getData = (id: string): Awaitable<string> =>
@@ -349,8 +378,8 @@ export type PartialProp<T, K extends keyof T> = Omit<T, K> &
  * const result = getData("cached");
  * const cached = isPromiseLike(result) ? await result : result;
  *
- * expect(fetched).toBe("fetched missing");
- * expect(cached).toBe("from cache");
+ * assertEqual(fetched, "fetched missing");
+ * assertEqual(cached, "from cache");
  * ```
  */
 export type Awaitable<T> = T | PromiseLike<T>;
@@ -364,7 +393,11 @@ export type Awaitable<T> = T | PromiseLike<T>;
  * ### Conditional awaiting
  *
  * ```ts
- * import { isPromiseLike, type Awaitable } from "@evolu/common";
+ * import {
+ *   assertTrue,
+ *   isPromiseLike,
+ *   type Awaitable,
+ * } from "@evolu/common";
  *
  * const cache = new Map([["cached", true]]);
  * const validate = (id: string): Awaitable<boolean> =>
@@ -373,7 +406,7 @@ export type Awaitable<T> = T | PromiseLike<T>;
  * const result = validate("cached");
  * const isValid = isPromiseLike(result) ? await result : result;
  *
- * expect(isValid).toBe(true);
+ * assertTrue(isValid);
  * ```
  */
 export const isPromiseLike = <T>(
@@ -387,6 +420,40 @@ export type CompileTimeError<
   Message extends string,
 > = `⛔ ${Context} error: ${Message}`;
 
+/**
+ * Returns whether two types are identical according to TypeScript.
+ *
+ * Unlike mutual assignability, this distinguishes narrower literals, `any`,
+ * `unknown`, `never`, optional properties, and readonly properties.
+ * Intersection types are not normalized; apply {@link Simplify} explicitly when
+ * normalization is part of the intended comparison.
+ *
+ * ### Exact type equality
+ *
+ * ```ts
+ * import { assertType, type IsSameType } from "@evolu/common";
+ *
+ * assertType<
+ *   true,
+ *   IsSameType<{ readonly id: string }, { readonly id: string }>
+ * >();
+ * assertType<false, IsSameType<"ready", string>>();
+ * ```
+ */
+export type IsSameType<A, B> =
+  (<T>() => T extends (A & T) | T ? true : false) extends <T>() => T extends
+    (B & T) | T
+    ? true
+    : false
+    ? [A] extends [never]
+      ? [B] extends [never]
+        ? true
+        : false
+      : [B] extends [never]
+        ? false
+        : true
+    : false;
+
 /** Returns whether a type is a union. */
 export type IsUnion<T, Whole = T> = [T] extends [never]
   ? false
@@ -420,7 +487,7 @@ export type ParameterIntersection<T> = [T] extends [(value: infer I) => void]
  * ### Preserving discriminated unions
  *
  * ```ts
- * import type { DistributiveOmit } from "@evolu/common";
+ * import { assertType, type DistributiveOmit } from "@evolu/common";
  *
  * type Event =
  *   | { type: "a"; a: string; shared: number }
@@ -428,8 +495,9 @@ export type ParameterIntersection<T> = [T] extends [(value: infer I) => void]
  *
  * type Payload = DistributiveOmit<Event, "shared">;
  *
- * expectTypeOf<Payload>().toEqualTypeOf<
- *   { type: "a"; a: string } | { type: "b"; b: number }
+ * assertType<
+ *   { type: "a"; a: string } | { type: "b"; b: number },
+ *   Payload
  * >();
  * ```
  */

package/src/WebSocket.ts

@@ -53,6 +53,10 @@ import { ArrayBuffer, String, Uint8Array, type Typed } from "./Type.ts";
  *
  * ```ts
  * import {
+ *   assert,
+ *   assertEqual,
+ *   assertOk,
+ *   assertTrue,
  *   createRun,
  *   createWebSocket,
  *   testCreateWebSocket,
@@ -70,9 +74,6 @@ import { ArrayBuffer, String, Uint8Array, type Typed } from "./Type.ts";
  *       createSocket("wss://example.com", {
  *         protocols: ["evolu"],
  *         binaryType: "arraybuffer",
- *         onOpen: () => console.log("Connected"),
- *         onMessage: (data) => console.log("Received:", data),
- *         onClose: () => console.log("Disconnected"),
  *       }),
  *     );
  *     return socket.send("Hello");
@@ -81,10 +82,17 @@ import { ArrayBuffer, String, Uint8Array, type Typed } from "./Type.ts";
  * const socketFactory = testCreateWebSocket();
  * await using run = createRun();
  *
- * expectOk(await run(connectAndSend(socketFactory)), undefined);
- * expect(socketFactory.sentMessages).toEqual([
+ * assertOk(await run(connectAndSend(socketFactory)), undefined);
+ * assertTrue(socketFactory.sentMessages.length === 1);
+ * const message = socketFactory.sentMessages[0];
+ * assert(
+ *   message !== undefined && typeof message.data === "string",
+ *   "Expected a text message.",
+ * );
+ * assertEqual(
+ *   { url: message.url, data: message.data },
  *   { url: "wss://example.com", data: "Hello" },
- * ]);
+ * );
  * ```
  */
 export interface WebSocket extends AsyncDisposable {

package/src/Worker.ts

@@ -64,6 +64,7 @@ export interface MessagePort<Input, Output = never> extends Disposable {
    *
    * ```ts
    * import {
+   *   assertType,
    *   createMessageChannel,
    *   type NativeMessagePort,
    * } from "@evolu/common";
@@ -79,9 +80,7 @@ export interface MessagePort<Input, Output = never> extends Disposable {
    *   port: consoleChannel.port1.native,
    * };
    *
-   * expectTypeOf(init.port).toEqualTypeOf<
-   *   NativeMessagePort<ConsoleMessage>
-   * >();
+   * assertType<NativeMessagePort<ConsoleMessage>, typeof init.port>();
    * ```
    */
   readonly native: NativeMessagePort<Input, Output>;
@@ -146,6 +145,7 @@ export type WorkerDeps = ConsoleDep &
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createMessageChannel,
  *   createMessagePort,
  *   createSharedWorker,
@@ -183,14 +183,18 @@ export type WorkerDeps = ConsoleDep &
  * ]);
  * queryChannel.port1.postMessage({ text: "all todos" });
  *
- * expect(await response.promise).toEqual({ rows: ["all todos"] });
+ * assertEqual(await response.promise, { rows: ["all todos"] });
  * ```
  *
  * On the worker side, attach the handler after asynchronous initialization;
  * messages sent earlier remain queued:
  *
  * ```ts
- * import { createMessageChannel, createMessagePort } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   createMessageChannel,
+ *   createMessagePort,
+ * } from "@evolu/common";
  *
  * interface Query {
  *   readonly text: string;
@@ -211,7 +215,7 @@ export type WorkerDeps = ConsoleDep &
  * };
  * await allReceived.promise;
  *
- * expect(received).toEqual([
+ * assertEqual(received, [
  *   { text: "all todos" },
  *   { text: "completed todos" },
  * ]);

package/src/intl/_en.ts

@@ -39,6 +39,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -345,10 +346,6 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet") {
     return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "The value is an instance of a Set subclass, but a Set Output must be a direct Set instance.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -359,6 +356,25 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in English. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `An excess Map property ${safelyStringifyUnknownValue(issue.key)} is not allowed.`;
+    case "Key":
+      return `A Map key at index ${issue.index} is invalid.`;
+    case "Value":
+      return `A Map value at index ${issue.index} is invalid.`;
+    case "Collision":
+      return `Map keys at indexes ${issue.previousIndex} and ${issue.index} decode to the same key ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formats a TupleError in English. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/ar.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -285,8 +286,6 @@ export const formatArrayError: TypeErrorFormatter<ArrayError> = (error) => {
 export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `القيمة ${safelyStringifyUnknownValue(error.reason.value)} ليست Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "القيمة مثيل لفئة فرعية من Set، لكن مخرج Set يجب أن يكون مثيل Set مباشراً.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -296,6 +295,22 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in Arabic. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `القيمة ${safelyStringifyUnknownValue(error.reason.value)} ليست Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `خاصية Map زائدة ${safelyStringifyUnknownValue(issue.key)} غير مسموح بها.`;
+    case "Key":
+    case "Value":
+      return `عنصر Map عند الفهرس ${issue.index} غير صالح.`;
+    case "Collision":
+      return `مفتاحا Map ${safelyStringifyUnknownValue(issue.previousKey)} و${safelyStringifyUnknownValue(issue.key)} يُفك ترميزهما إلى المفتاح نفسه ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formats a TupleError in Arabic. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/bn.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -334,10 +335,6 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet") {
     return `${safelyStringifyUnknownValue(error.reason.value)} মানটি Set নয়।`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "মানটি Set subclass-এর instance, কিন্তু Set Output অবশ্যই সরাসরি Set instance হতে হবে।";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -348,6 +345,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in Bengali. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `${safelyStringifyUnknownValue(error.reason.value)} মানটি Map নয়।`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `অতিরিক্ত Map property ${safelyStringifyUnknownValue(issue.key)} অনুমোদিত নয়।`;
+    case "Key":
+    case "Value":
+      return `Map-এর index ${issue.index}-এর element অবৈধ।`;
+    case "Collision":
+      return `Map key ${safelyStringifyUnknownValue(issue.previousKey)} এবং ${safelyStringifyUnknownValue(issue.key)} decode হয়ে একই key ${safelyStringifyUnknownValue(issue.outputKey)} হয়।`;
+  }
+};
+
 /** Formats a TupleError in Bengali. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/ca.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -336,10 +337,6 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet") {
     return `El valor ${safelyStringifyUnknownValue(error.reason.value)} no és un Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "El valor és una instància d’una subclasse de Set, però l’Output de Set ha de ser una instància directa de Set.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -350,6 +347,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formata MapError en català. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `El valor ${safelyStringifyUnknownValue(error.reason.value)} no és un Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `No es permet la propietat Map addicional ${safelyStringifyUnknownValue(issue.key)}.`;
+    case "Key":
+    case "Value":
+      return `L’element de Map a l’índex ${issue.index} no és vàlid.`;
+    case "Collision":
+      return `Les claus de Map ${safelyStringifyUnknownValue(issue.previousKey)} i ${safelyStringifyUnknownValue(issue.key)} es descodifiquen a la mateixa clau ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formata TupleError en català. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/cs.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -335,10 +336,6 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet") {
     return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} není Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "Hodnota je instancí podtřídy Setu, ale Output typu Set musí být přímou instancí Setu.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in Czech. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} není Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Map obsahuje nepovolenou vlastní vlastnost ${safelyStringifyUnknownValue(issue.key)}.`;
+    case "Key":
+    case "Value":
+      return `Prvek Mapu na indexu ${issue.index} není platný.`;
+    case "Collision":
+      return `Klíče Mapu ${safelyStringifyUnknownValue(issue.previousKey)} a ${safelyStringifyUnknownValue(issue.key)} se dekódují na stejný klíč ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formats a TupleError in Czech. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/da.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -336,10 +337,6 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet") {
     return `Værdien ${safelyStringifyUnknownValue(error.reason.value)} er ikke et Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "Værdien er en instans af en Set-underklasse, men et Set Output skal være en direkte Set-instans.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -350,6 +347,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formaterer MapError på dansk. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Værdien ${safelyStringifyUnknownValue(error.reason.value)} er ikke et Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Den ekstra Map-egenskab ${safelyStringifyUnknownValue(issue.key)} er ikke tilladt.`;
+    case "Key":
+    case "Value":
+      return `Et Map-element på indeks ${issue.index} er ugyldigt.`;
+    case "Collision":
+      return `Map-nøglerne ${safelyStringifyUnknownValue(issue.previousKey)} og ${safelyStringifyUnknownValue(issue.key)} afkodes til den samme nøgle ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formaterer TupleError på dansk. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>