@evolu/common 8.5.0 → 8.6.0

package/src/intl/ml.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 `മൂല്യം ${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) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** MapError മലയാളത്തിൽ ഫോർമാറ്റ് ചെയ്യുന്നു. */
+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 `index ${issue.index}-ലെ Map element അസാധുവാണ്.`;
+    case "Collision":
+      return `Map keys ${safelyStringifyUnknownValue(issue.previousKey)} ഉം ${safelyStringifyUnknownValue(issue.key)} ഉം decode ചെയ്യുമ്പോൾ അതേ key ${safelyStringifyUnknownValue(issue.outputKey)} ലഭിക്കുന്നു.`;
+  }
+};
+
 /** TupleError മലയാളത്തിൽ ഫോർമാറ്റ് ചെയ്യുന്നു. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/mr.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 `मूल्य ${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) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in Marathi. */
+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 `index ${issue.index} वरील Map element अवैध आहे.`;
+    case "Collision":
+      return `Map keys ${safelyStringifyUnknownValue(issue.previousKey)} आणि ${safelyStringifyUnknownValue(issue.key)} decode केल्यावर तीच key ${safelyStringifyUnknownValue(issue.outputKey)} मिळते.`;
+  }
+};
+
 /** Formats a TupleError in Marathi. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/ms.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -284,8 +285,6 @@ export const formatArrayError: TypeErrorFormatter<ArrayError> = (error) => {
 export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `Nilai ${safelyStringifyUnknownValue(error.reason.value)} bukan Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "Nilai itu ialah instance subkelas Set, tetapi Output Set mestilah instance Set langsung.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -294,6 +293,22 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
       return `Elemen Set pada indeks ${issue.index} tidak sah.`;
   }
 };
+
+/** Formats a MapError in Malay. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `Nilai ${safelyStringifyUnknownValue(error.reason.value)} bukan Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Sifat Map berlebihan ${safelyStringifyUnknownValue(issue.key)} tidak dibenarkan.`;
+    case "Key":
+    case "Value":
+      return `Elemen Map pada indeks ${issue.index} tidak sah.`;
+    case "Collision":
+      return `Kunci Map ${safelyStringifyUnknownValue(issue.previousKey)} dan ${safelyStringifyUnknownValue(issue.key)} dinyahkod kepada kunci yang sama, ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
 /** Formats a TupleError in Malay. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/nb.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -238,8 +239,6 @@ export const formatArrayError: TypeErrorFormatter<ArrayError> = (error) => {
 export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `En verdi ${safelyStringifyUnknownValue(error.reason.value)} er ikke et Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "Verdien er en instans av en Set-underklasse, men et Set Output må være en direkte Set-instans.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -249,6 +248,21 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `En verdi ${safelyStringifyUnknownValue(error.reason.value)} er ikke et Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `En overflødig Map-egenskap ${safelyStringifyUnknownValue(issue.key)} er ikke tillatt.`;
+    case "Key":
+    case "Value":
+      return `Et Map-element med indeks ${issue.index} er ugyldig.`;
+    case "Collision":
+      return `Map-nøklene ${safelyStringifyUnknownValue(issue.previousKey)} og ${safelyStringifyUnknownValue(issue.key)} dekoder til samme nøkkel ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>
 > = (error) => {

package/src/intl/nl.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 `Een waarde ${safelyStringifyUnknownValue(error.reason.value)} is geen Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "De waarde is een instantie van een Set-subklasse, maar een Set Output moet een directe Set-instantie zijn.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -350,6 +347,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formatteert een MapError in het Nederlands. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Een waarde ${safelyStringifyUnknownValue(error.reason.value)} is geen Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Een overbodige Map-eigenschap ${safelyStringifyUnknownValue(issue.key)} is niet toegestaan.`;
+    case "Key":
+    case "Value":
+      return `Een Map-element op index ${issue.index} is ongeldig.`;
+    case "Collision":
+      return `Map-sleutels ${safelyStringifyUnknownValue(issue.previousKey)} en ${safelyStringifyUnknownValue(issue.key)} decoderen naar dezelfde sleutel ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formatteert een TupleError in het Nederlands. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/pa.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 `ਮੁੱਲ ${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) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** MapError ਨੂੰ ਪੰਜਾਬੀ ਵਿੱਚ format ਕਰਦਾ ਹੈ। */
+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 `index ${issue.index} ਉੱਤੇ Map element ਅਵੈਧ ਹੈ।`;
+    case "Collision":
+      return `Map keys ${safelyStringifyUnknownValue(issue.previousKey)} ਅਤੇ ${safelyStringifyUnknownValue(issue.key)} decode ਹੋ ਕੇ ਇੱਕੋ key ${safelyStringifyUnknownValue(issue.outputKey)} ਬਣ ਜਾਂਦੀਆਂ ਹਨ।`;
+  }
+};
+
 /** TupleError ਨੂੰ ਪੰਜਾਬੀ ਵਿੱਚ format ਕਰਦਾ ਹੈ। */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/pl.ts

@@ -312,8 +312,6 @@ export const formatSetError: Type.TypeErrorFormatter<Type.SetError> = (
 ) => {
   if (error.reason.kind === "NotSet")
     return `Wartość ${safelyStringifyUnknownValue(error.reason.value)} nie jest Setem.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "Wartość jest instancją podklasy Set, ale wynik typu Set musi być bezpośrednią instancją Set.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -323,6 +321,24 @@ export const formatSetError: Type.TypeErrorFormatter<Type.SetError> = (
   }
 };
 
+/** Formats a MapError in Polish. */
+export const formatMapError: Type.TypeErrorFormatter<Type.MapError> = (
+  error,
+) => {
+  if (error.reason.kind === "NotMap")
+    return `Wartość ${safelyStringifyUnknownValue(error.reason.value)} nie jest Mapem.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Nadmiarowa właściwość Map ${safelyStringifyUnknownValue(issue.key)} jest niedozwolona.`;
+    case "Key":
+    case "Value":
+      return `Element Map o indeksie ${issue.index} jest nieprawidłowy.`;
+    case "Collision":
+      return `Klucze Map ${safelyStringifyUnknownValue(issue.previousKey)} i ${safelyStringifyUnknownValue(issue.key)} dekodują się do tego samego klucza ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formats a TupleError in Polish. */
 export const formatTupleError: Type.TypeErrorFormatter<
   Type.TupleError | Type.TupleElementsError<Type.TypeError>

package/src/intl/pt-BR.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 `O valor ${safelyStringifyUnknownValue(error.reason.value)} não é um Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "O valor é uma instância de uma subclasse de Set, mas uma saída de Set deve ser uma instância direta de Set.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formata um MapError em português brasileiro. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `O valor ${safelyStringifyUnknownValue(error.reason.value)} não é um Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `A propriedade extra de Map ${safelyStringifyUnknownValue(issue.key)} não é permitida.`;
+    case "Key":
+    case "Value":
+      return `O elemento de Map no índice ${issue.index} é inválido.`;
+    case "Collision":
+      return `As chaves de Map ${safelyStringifyUnknownValue(issue.previousKey)} e ${safelyStringifyUnknownValue(issue.key)} decodificam para a mesma chave ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formata um TupleError em português brasileiro. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/pt.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -292,8 +293,6 @@ export const formatArrayError: TypeErrorFormatter<ArrayError> = (error) => {
 export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `O valor ${safelyStringifyUnknownValue(error.reason.value)} não é um Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "O valor é uma instância de uma subclasse de Set, mas uma saída de Set tem de ser uma instância direta de Set.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -303,6 +302,22 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formata um MapError em português. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `O valor ${safelyStringifyUnknownValue(error.reason.value)} não é um Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Uma propriedade Map excedente ${safelyStringifyUnknownValue(issue.key)} não é permitida.`;
+    case "Key":
+    case "Value":
+      return `Um elemento de Map no índice ${issue.index} é inválido.`;
+    case "Collision":
+      return `As chaves de Map ${safelyStringifyUnknownValue(issue.previousKey)} e ${safelyStringifyUnknownValue(issue.key)} descodificam para a mesma chave ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formata um TupleError em português. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/ro.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 `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "Valoarea este o instanță a unei subclase Set, dar un Output Set trebuie să fie o instanță Set directă.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -350,6 +347,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formatează un MapError în română. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Valoarea ${safelyStringifyUnknownValue(error.reason.value)} nu este un Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `O proprietate Map în exces ${safelyStringifyUnknownValue(issue.key)} nu este permisă.`;
+    case "Key":
+    case "Value":
+      return `Elementul Map de la indexul ${issue.index} nu este valid.`;
+    case "Collision":
+      return `Cheile Map ${safelyStringifyUnknownValue(issue.previousKey)} și ${safelyStringifyUnknownValue(issue.key)} se decodează la aceeași cheie ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formatează un TupleError în română. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/sk.ts

@@ -30,6 +30,7 @@ import type {
   LessThanError,
   LessThanOrEqualToError,
   LiteralError,
+  MapError,
   MaxLengthError,
   MinLengthError,
   MnemonicError,
@@ -286,8 +287,6 @@ export const formatArrayError: TypeErrorFormatter<ArrayError> = (error) => {
 export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "Hodnota je inštanciou podtriedy Set, ale výstup typu Set musí byť priamou inštanciou Set.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -296,6 +295,22 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
       return `Prvok Set na indexe ${issue.index} nie je platný.`;
   }
 };
+
+/** Formats a MapError in Slovak. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} nie je Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Map obsahuje nepovolenú vlastnosť ${safelyStringifyUnknownValue(issue.key)}.`;
+    case "Key":
+    case "Value":
+      return `Prvok Map na indexe ${issue.index} nie je platný.`;
+    case "Collision":
+      return `Kľúče Map ${safelyStringifyUnknownValue(issue.previousKey)} a ${safelyStringifyUnknownValue(issue.key)} sa dekódujú na rovnaký kľúč ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
 /** Formats a TupleError in Slovak. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/sl.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 `Vrednost ${safelyStringifyUnknownValue(error.reason.value)} ni Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "Vrednost je primerek podrazreda Set, vendar mora biti izhod tipa Set neposreden primerek Set.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formats a MapError in Slovene. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Vrednost ${safelyStringifyUnknownValue(error.reason.value)} ni Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Dodatna lastnost Map ${safelyStringifyUnknownValue(issue.key)} ni dovoljena.`;
+    case "Key":
+    case "Value":
+      return `Element Map na indeksu ${issue.index} ni veljaven.`;
+    case "Collision":
+      return `Ključa Map ${safelyStringifyUnknownValue(issue.previousKey)} in ${safelyStringifyUnknownValue(issue.key)} se dekodirata v isti ključ ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formats a TupleError in Slovene. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/sv.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ärdet ${safelyStringifyUnknownValue(error.reason.value)} är inte en Set.`;
   }
-  if (error.reason.kind === "UnexpectedPrototype") {
-    return "Värdet är en instans av en Set-underklass, men en Set Output måste vara en direkt Set-instans.";
-  }
-
   const issue = error.reason.issues[0];
 
   switch (issue.kind) {
@@ -350,6 +347,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** Formaterar ett MapError på svenska. */
+export const formatMapError: TypeErrorFormatter<MapError> = (error) => {
+  if (error.reason.kind === "NotMap") {
+    return `Värdet ${safelyStringifyUnknownValue(error.reason.value)} är inte en Map.`;
+  }
+  const issue = error.reason.issues[0];
+
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `En extra Map-egenskap ${safelyStringifyUnknownValue(issue.key)} är inte tillåten.`;
+    case "Key":
+    case "Value":
+      return `Ett Map-element vid index ${issue.index} är ogiltigt.`;
+    case "Collision":
+      return `Map-nycklarna ${safelyStringifyUnknownValue(issue.previousKey)} och ${safelyStringifyUnknownValue(issue.key)} avkodas till samma nyckel ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
+
 /** Formaterar ett TupleError på svenska. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/sw.ts

@@ -200,8 +200,6 @@ export const formatArrayError: T.TypeErrorFormatter<T.ArrayError> = (error) => {
 export const formatSetError: T.TypeErrorFormatter<T.SetError> = (error) => {
   if (error.reason.kind === "NotSet")
     return `Thamani ${safelyStringifyUnknownValue(error.reason.value)} si Set.`;
-  if (error.reason.kind === "UnexpectedPrototype")
-    return "Thamani ni instance ya subclass ya Set, lakini Set Output lazima iwe instance ya Set ya moja kwa moja.";
   const issue = error.reason.issues[0];
   switch (issue.kind) {
     case "ExcessProperty":
@@ -210,6 +208,21 @@ export const formatSetError: T.TypeErrorFormatter<T.SetError> = (error) => {
       return `Kipengele cha Set katika faharasa ${issue.index} si halali.`;
   }
 };
+
+export const formatMapError: T.TypeErrorFormatter<T.MapError> = (error) => {
+  if (error.reason.kind === "NotMap")
+    return `Thamani ${safelyStringifyUnknownValue(error.reason.value)} si Map.`;
+  const issue = error.reason.issues[0];
+  switch (issue.kind) {
+    case "ExcessProperty":
+      return `Sifa ya Map ya ziada ${safelyStringifyUnknownValue(issue.key)} hairuhusiwi.`;
+    case "Key":
+    case "Value":
+      return `Kipengele cha Map katika faharasa ${issue.index} si halali.`;
+    case "Collision":
+      return `Funguo za Map ${safelyStringifyUnknownValue(issue.previousKey)} na ${safelyStringifyUnknownValue(issue.key)} zinafumbuliwa kuwa ufunguo uleule ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+  }
+};
 export const formatTupleError: T.TypeErrorFormatter<
   T.TupleError | T.TupleElementsError<T.TypeError>
 > = (error) => {

package/src/intl/ta.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 `மதிப்பு ${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) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** MapError-ஐ தமிழில் வடிவமைக்கிறது. */
+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 `index ${issue.index}-இல் உள்ள Map element செல்லுபடியாகாது.`;
+    case "Collision":
+      return `Map key-கள் ${safelyStringifyUnknownValue(issue.previousKey)} மற்றும் ${safelyStringifyUnknownValue(issue.key)} ஒரே key ${safelyStringifyUnknownValue(issue.outputKey)}-ஆக decode ஆகின்றன.`;
+  }
+};
+
 /** TupleError-ஐ தமிழில் வடிவமைக்கிறது. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>

package/src/intl/te.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 `విలువ ${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) {
@@ -349,6 +346,24 @@ export const formatSetError: TypeErrorFormatter<SetError> = (error) => {
   }
 };
 
+/** MapErrorను తెలుగులో ఫార్మాట్ చేస్తుంది. */
+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 `సూచిక ${issue.index} వద్ద Map element చెల్లదు.`;
+    case "Collision":
+      return `Map keys ${safelyStringifyUnknownValue(issue.previousKey)} మరియు ${safelyStringifyUnknownValue(issue.key)} ఒకే key ${safelyStringifyUnknownValue(issue.outputKey)} కు decode అవుతాయి.`;
+  }
+};
+
 /** TupleErrorను తెలుగులో ఫార్మాట్ చేస్తుంది. */
 export const formatTupleError: TypeErrorFormatter<
   TupleError | TupleElementsError<TypeError>