@evolu/common 8.2.0 → 8.3.1

package/dist/src/intl/hr.js

@@ -0,0 +1,265 @@
+/**
+ * Croatian Evolu Type error formatters.
+ *
+ * @module
+ */
+import { assertNonNullable } from "../Assert.js";
+import { safelyStringifyUnknownValue } from "../String.js";
+const formatTypeOfError = (error) => {
+    const typeOf = {
+        String: "niz znakova",
+        Number: "broj",
+        BigInt: "bigint",
+        Boolean: "logička vrijednost",
+        Symbol: "simbol",
+        Function: "funkcija",
+    }[error.expected];
+    return `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije ${typeOf}.`;
+};
+const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
+    ? `Vrijednost ${safelyStringifyUnknownValue(reason.value)} nije objekt.`
+    : "Vrijednost je objekt, ali izlaz tipa Object mora biti običan objekt ili imati prototip null.";
+/** Formats a NeverError in Croatian. */
+export const formatNeverError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjana za tip Never.`;
+/** Formats a String TypeOfError in Croatian. */
+export const formatStringError = formatTypeOfError;
+/** Formats a TemplateLiteralError in Croatian. */
+export const formatTemplateLiteralError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} ne odgovara predlošku stringa.`;
+/** Formats a Number TypeOfError in Croatian. */
+export const formatNumberError = formatTypeOfError;
+/** Formats a BigInt TypeOfError in Croatian. */
+export const formatBigIntError = formatTypeOfError;
+/** Formats a Boolean TypeOfError in Croatian. */
+export const formatBooleanError = formatTypeOfError;
+/** Formats a Symbol TypeOfError in Croatian. */
+export const formatSymbolError = formatTypeOfError;
+/** Formats a Function TypeOfError in Croatian. */
+export const formatFunctionError = formatTypeOfError;
+/** Formats an EvoluTypeError in Croatian. */
+export const formatEvoluTypeError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije Evolu Type.`;
+/** Formats an ObjectTagError in Croatian. */
+export const formatObjectTagError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nema očekivanu oznaku objekta ${safelyStringifyUnknownValue(error.expected)}.`;
+/** Formats an InstanceOfError in Croatian. */
+export const formatInstanceOfError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije instanca klase ${error.constructorName}.`;
+/** Formats a LiteralError in Croatian. */
+export const formatLiteralError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije strogo jednaka očekivanom literalu: ${globalThis.String(error.expected)}.`;
+/** Formats a UnionError in Croatian. */
+export const formatUnionError = () => "Vrijednost ne odgovara nijednoj dopuštenoj varijanti.";
+/** Formats a DateIsoError in Croatian. */
+export const formatDateIsoError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije kanonski ISO niz datuma i vremena.`;
+/** Formats a DateIsoFromDateError in Croatian. */
+export const formatDateIsoFromDateError = () => "Date se ne može predstaviti kao DateIso.";
+/** Formats a DecimalStringError in Croatian. */
+export const formatDecimalStringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti kanonski decimalni niz.`;
+/** Formats an Int64Error in Croatian. */
+export const formatInt64Error = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani predznačeni 64-bitni cijeli broj (Int64).`;
+/** Formats a UInt64Error in Croatian. */
+export const formatUInt64Error = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani nepredznačeni 64-bitni cijeli broj (UInt64).`;
+/** Formats an Int64StringError in Croatian. */
+export const formatInt64StringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani Int64 niz.`;
+/** Formats a CapitalizedError in Croatian. */
+export const formatCapitalizedError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora počinjati velikim slovom.`;
+/** Formats a TrimmedError in Croatian. */
+export const formatTrimmedError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} ne smije imati razmake na početku ni na kraju.`;
+/** Formats a MinLengthError in Croatian. */
+export const formatMinLengthError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} ne zadovoljava najmanju duljinu od ${error.min}.`;
+/** Formats a MaxLengthError in Croatian. */
+export const formatMaxLengthError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} premašuje najveću duljinu od ${error.max}.`;
+/** Formats a LengthError in Croatian. */
+export const formatLengthError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nema potrebnu duljinu od ${error.exact}.`;
+/** Formats a RegexError in Croatian. */
+export const formatRegexError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} ne odgovara /${error.source}/${error.flags}.`;
+/** Formats a Base64UrlError in Croatian. */
+export const formatBase64UrlError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani Base64Url niz.`;
+/** Formats a NameError in Croatian. */
+export const formatNameError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani Name.`;
+/** Formats a MnemonicError in Croatian. */
+export const formatMnemonicError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjana engleska BIP39 mnemonika.`;
+/** Formats an IdError in Croatian. */
+export const formatIdError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani Id.`;
+/** Formats a TableIdError in Croatian. */
+export const formatTableIdError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} nije valjani Id za tablicu ${error.table}.`;
+/** Formats a NonNegativeError in Croatian. */
+export const formatNonNegativeError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti nenegativna (>= 0).`;
+/** Formats a NonNegativeDecimalStringError in Croatian. */
+export const formatNonNegativeDecimalStringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti nenegativni decimalni niz.`;
+/** Formats a PositiveError in Croatian. */
+export const formatPositiveError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti pozitivna (> 0).`;
+/** Formats a PositiveDecimalStringError in Croatian. */
+export const formatPositiveDecimalStringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti pozitivni decimalni niz.`;
+/** Formats a NonPositiveError in Croatian. */
+export const formatNonPositiveError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti nepozitivna (<= 0).`;
+/** Formats a NonPositiveDecimalStringError in Croatian. */
+export const formatNonPositiveDecimalStringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti nepozitivni decimalni niz.`;
+/** Formats a NegativeError in Croatian. */
+export const formatNegativeError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti negativna (< 0).`;
+/** Formats a NegativeDecimalStringError in Croatian. */
+export const formatNegativeDecimalStringError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti negativni decimalni niz.`;
+/** Formats an IntError in Croatian. */
+export const formatIntError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti siguran cijeli broj.`;
+/** Formats a GreaterThanError in Croatian. */
+export const formatGreaterThanError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti veća od ${error.min}.`;
+/** Formats a GreaterThanOrEqualToError in Croatian. */
+export const formatGreaterThanOrEqualToError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti veća ili jednaka ${error.min}.`;
+/** Formats a LessThanError in Croatian. */
+export const formatLessThanError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti manja od ${error.max}.`;
+/** Formats a LessThanOrEqualToError in Croatian. */
+export const formatLessThanOrEqualToError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti manja ili jednaka ${error.max}.`;
+/** Formats a NonNaNError in Croatian. */
+export const formatNonNaNError = () => "Vrijednost ne smije biti NaN.";
+/** Formats a FiniteError in Croatian. */
+export const formatFiniteError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti konačna.`;
+/** Formats a MultipleOfError in Croatian. */
+export const formatMultipleOfError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti višekratnik broja ${error.divisor}.`;
+/** Formats a BetweenError in Croatian. */
+export const formatBetweenError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} mora biti između ${error.min} i ${error.max}, uključujući granice.`;
+/** Formats an ArrayError in Croatian. */
+export const formatArrayError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Vrijednost ${safelyStringifyUnknownValue(error.reason.value)} nije polje.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Element polja na indeksu ${issue.index} nedostaje.`;
+        case "Accessor":
+            return `Element polja na indeksu ${issue.index} mora biti podatkovno svojstvo.`;
+        case "ExcessProperty":
+            return "Dodatno svojstvo polja nije dopušteno. Uklonite ga ili upotrijebite drugi Type.";
+        case "Element":
+            return `Element polja na indeksu ${issue.index} nije valjan.`;
+    }
+};
+/** Formats a SetError in Croatian. */
+export const formatSetError = (error) => {
+    if (error.reason.kind === "NotSet") {
+        return `Vrijednost ${safelyStringifyUnknownValue(error.reason.value)} nije Set.`;
+    }
+    if (error.reason.kind === "UnexpectedPrototype") {
+        return "Vrijednost je instanca podklase Set, ali izlaz tipa Set mora biti izravna instanca Set-a.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "ExcessProperty":
+            return `Dodatno svojstvo Set-a ${safelyStringifyUnknownValue(issue.key)} nije dopušteno.`;
+        case "Element":
+            return `Element Set-a na indeksu ${issue.index} nije valjan.`;
+    }
+};
+/** Formats a TupleError in Croatian. */
+export const formatTupleError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Vrijednost ${safelyStringifyUnknownValue(error.reason.value)} nije torka.`;
+    }
+    if (error.reason.kind === "InvalidLength") {
+        return `Torka mora sadržavati točno ${error.reason.expected} elemenata, ali vrijednost sadrži ${error.reason.actual}.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Element torke na indeksu ${issue.index} nedostaje.`;
+        case "Accessor":
+            return `Element torke na indeksu ${issue.index} mora biti podatkovno svojstvo.`;
+        case "ExcessProperty":
+            return "Dodatno svojstvo torke nije dopušteno. Uklonite ga ili upotrijebite drugi Type.";
+        case "Element":
+            return `Element torke na indeksu ${issue.index} nije valjan.`;
+    }
+};
+/** Formats a RecordError in Croatian. */
+export const formatRecordError = (error) => {
+    if (error.reason.kind === "NotRecord") {
+        return `Vrijednost ${safelyStringifyUnknownValue(error.reason.value)} nije Record.`;
+    }
+    if (error.reason.kind === "NotPlainRecord") {
+        return "Vrijednost je objekt, ali izlaz tipa Record mora biti običan objekt ili imati prototip null.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Key":
+            return `Ključ svojstva ${safelyStringifyUnknownValue(issue.key)} nije valjan.`;
+        case "Value":
+            return `Vrijednost svojstva ${safelyStringifyUnknownValue(issue.key)} nije valjana.`;
+        case "Accessor":
+            return `Svojstvo Record-a ${safelyStringifyUnknownValue(issue.key)} mora biti podatkovno svojstvo.`;
+        case "NonEnumerable":
+            return `Svojstvo Record-a ${safelyStringifyUnknownValue(issue.key)} mora biti nabrojivo.`;
+        case "Collision":
+            return `Ključevi Record-a ${safelyStringifyUnknownValue(issue.previousKey)} i ${safelyStringifyUnknownValue(issue.key)} dekodiraju se u isti ključ ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+    }
+};
+/** Formats an ObjectError in Croatian. */
+export const formatObjectError = (error) => {
+    if (error.reason.kind !== "Properties") {
+        return formatPlainObjectRootError(error.reason);
+    }
+    const key = Reflect.ownKeys(error.reason.errors).at(0);
+    assertNonNullable(key);
+    const propertyError = error.reason.errors[key];
+    assertNonNullable(propertyError);
+    if (propertyError.type === "ObjectPropertyAccess") {
+        switch (propertyError.reason) {
+            case "Accessor":
+                return "Svojstvo Object-a mora biti podatkovno svojstvo. Prije upotrebe ovog Type-a pretvorite vrijednosti pristupnika u obične podatke ili upotrijebite drugi Type.";
+            case "NonEnumerable":
+                return "Svojstvo Object-a mora biti nabrojivo. Učinite ga nabrojivim ili upotrijebite drugi Type.";
+        }
+    }
+    if (propertyError.type === "ObjectMissingProperty") {
+        return `Obavezno svojstvo ${safelyStringifyUnknownValue(key)} nedostaje.`;
+    }
+    if (typeof key === "symbol") {
+        return "Ključ svojstva Object-a mora biti niz. Uklonite svojstvo sa simbolom ili upotrijebite drugi Type.";
+    }
+    if (propertyError.type === "ObjectExcessProperty") {
+        return `Svojstvo ${safelyStringifyUnknownValue(key)} nije dopušteno. Uklonite ga ili upotrijebite drugi Type.`;
+    }
+    return `Svojstvo ${safelyStringifyUnknownValue(key)} nije valjano.`;
+};
+/** Formats a DiscriminatedUnionError in Croatian. */
+export const formatDiscriminatedUnionError = (error) => {
+    switch (error.reason.kind) {
+        case "Object":
+            return formatPlainObjectRootError(error.reason.error.reason);
+        case "PropertyAccess": {
+            const property = `Svojstvo diskriminatora ${safelyStringifyUnknownValue(error.reason.key)}`;
+            if (error.reason.reason === "Accessor") {
+                return `${property} mora biti podatkovno svojstvo.`;
+            }
+            if (error.reason.reason === "Inherited") {
+                return `${property} mora biti vlastito svojstvo.`;
+            }
+            return `${property} mora biti nabrojivo.`;
+        }
+        case "Discriminator":
+            return `Svojstvo diskriminatora ${safelyStringifyUnknownValue(error.reason.key)} ima neočekivanu vrijednost ${safelyStringifyUnknownValue(error.reason.value)}.`;
+        case "Member":
+            return `Odabrana varijanta ${safelyStringifyUnknownValue(error.reason.discriminator)} nije valjana.`;
+    }
+};
+/** Formats a JsonValueError in Croatian. */
+export const formatJsonValueError = (error) => {
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "InvalidType":
+            return `Vrijednost ${safelyStringifyUnknownValue(issue.value)} nije JSON vrijednost.`;
+        case "NonFiniteNumber":
+            return "JSON broj mora biti konačan.";
+        case "UnexpectedPrototype":
+            return "Vrijednost je objekt, ali objekt JsonValue mora biti običan objekt ili imati prototip null.";
+        case "Accessor":
+            return "JSON svojstvo mora biti podatkovno svojstvo. Prije upotrebe ovog Type-a pretvorite vrijednosti pristupnika u obične podatke ili upotrijebite drugi Type.";
+        case "NonEnumerable":
+            return "Svojstvo JSON objekta mora biti nabrojivo. Uklonite ga ili upotrijebite drugi Type.";
+        case "SymbolProperty":
+            return "Ključ svojstva JSON objekta mora biti niz. Uklonite svojstvo sa simbolom ili upotrijebite drugi Type.";
+        case "Hole":
+            return "Element JSON polja nedostaje.";
+        case "ExcessProperty":
+            return "Dodatno svojstvo JSON polja nije dopušteno. Uklonite ga ili upotrijebite drugi Type.";
+        case "CircularReference":
+            return "JsonValue ne smije sadržavati kružne reference.";
+    }
+};
+/** Formats a JsonError in Croatian. */
+export const formatJsonError = (error) => `Vrijednost ${safelyStringifyUnknownValue(error.value)} ne može se analizirati kao JsonValue.`;

package/dist/src/intl/hu.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Hungarian Evolu Type error formatters.
+ *
+ * @module
+ */
+import type { ArrayError, Base64UrlError, BetweenError, CapitalizedError, DateIsoError, DateIsoFromDateError, DecimalStringError, DiscriminatedUnionError, EvoluTypeError, FiniteError, GreaterThanError, GreaterThanOrEqualToError, InstanceOfError, Int64Error, Int64StringError, IntError, IdError, JsonError, JsonValueError, LengthError, LessThanError, LessThanOrEqualToError, LiteralError, MaxLengthError, MinLengthError, MnemonicError, MultipleOfError, NegativeDecimalStringError, NegativeError, NameError, NeverError, NonNaNError, NonNegativeDecimalStringError, NonNegativeError, NonPositiveDecimalStringError, NonPositiveError, ObjectError, ObjectTagError, PositiveDecimalStringError, PositiveError, RecordError, RegexError, SetError, TableIdError, TemplateLiteralError, TrimmedError, TupleElementsError, TupleError, TypeError, TypeErrorFormatter, TypeOfError, UInt64Error, UnionError } from "../Type.ts";
+/** Formats a NeverError in Hungarian. */
+export declare const formatNeverError: TypeErrorFormatter<NeverError>;
+export declare const formatStringError: TypeErrorFormatter<TypeOfError<"String">>;
+export declare const formatTemplateLiteralError: TypeErrorFormatter<TemplateLiteralError>;
+export declare const formatNumberError: TypeErrorFormatter<TypeOfError<"Number">>;
+export declare const formatBigIntError: TypeErrorFormatter<TypeOfError<"BigInt">>;
+export declare const formatBooleanError: TypeErrorFormatter<TypeOfError<"Boolean">>;
+export declare const formatSymbolError: TypeErrorFormatter<TypeOfError<"Symbol">>;
+export declare const formatFunctionError: TypeErrorFormatter<TypeOfError<"Function">>;
+export declare const formatEvoluTypeError: TypeErrorFormatter<EvoluTypeError>;
+export declare const formatObjectTagError: TypeErrorFormatter<ObjectTagError>;
+export declare const formatInstanceOfError: TypeErrorFormatter<InstanceOfError>;
+export declare const formatLiteralError: TypeErrorFormatter<LiteralError>;
+export declare const formatUnionError: TypeErrorFormatter<UnionError>;
+export declare const formatDateIsoError: TypeErrorFormatter<DateIsoError>;
+export declare const formatDateIsoFromDateError: TypeErrorFormatter<DateIsoFromDateError>;
+export declare const formatDecimalStringError: TypeErrorFormatter<DecimalStringError>;
+export declare const formatInt64Error: TypeErrorFormatter<Int64Error>;
+export declare const formatUInt64Error: TypeErrorFormatter<UInt64Error>;
+export declare const formatInt64StringError: TypeErrorFormatter<Int64StringError>;
+export declare const formatCapitalizedError: TypeErrorFormatter<CapitalizedError>;
+export declare const formatTrimmedError: TypeErrorFormatter<TrimmedError>;
+export declare const formatMinLengthError: TypeErrorFormatter<MinLengthError>;
+export declare const formatMaxLengthError: TypeErrorFormatter<MaxLengthError>;
+export declare const formatLengthError: TypeErrorFormatter<LengthError>;
+export declare const formatRegexError: TypeErrorFormatter<RegexError>;
+export declare const formatBase64UrlError: TypeErrorFormatter<Base64UrlError>;
+export declare const formatNameError: TypeErrorFormatter<NameError>;
+export declare const formatMnemonicError: TypeErrorFormatter<MnemonicError>;
+export declare const formatIdError: TypeErrorFormatter<IdError>;
+export declare const formatTableIdError: TypeErrorFormatter<TableIdError>;
+export declare const formatNonNegativeError: TypeErrorFormatter<NonNegativeError>;
+export declare const formatNonNegativeDecimalStringError: TypeErrorFormatter<NonNegativeDecimalStringError>;
+export declare const formatPositiveError: TypeErrorFormatter<PositiveError>;
+export declare const formatPositiveDecimalStringError: TypeErrorFormatter<PositiveDecimalStringError>;
+export declare const formatNonPositiveError: TypeErrorFormatter<NonPositiveError>;
+export declare const formatNonPositiveDecimalStringError: TypeErrorFormatter<NonPositiveDecimalStringError>;
+export declare const formatNegativeError: TypeErrorFormatter<NegativeError>;
+export declare const formatNegativeDecimalStringError: TypeErrorFormatter<NegativeDecimalStringError>;
+export declare const formatIntError: TypeErrorFormatter<IntError>;
+export declare const formatGreaterThanError: TypeErrorFormatter<GreaterThanError>;
+export declare const formatGreaterThanOrEqualToError: TypeErrorFormatter<GreaterThanOrEqualToError>;
+export declare const formatLessThanError: TypeErrorFormatter<LessThanError>;
+export declare const formatLessThanOrEqualToError: TypeErrorFormatter<LessThanOrEqualToError>;
+export declare const formatNonNaNError: TypeErrorFormatter<NonNaNError>;
+export declare const formatFiniteError: TypeErrorFormatter<FiniteError>;
+export declare const formatMultipleOfError: TypeErrorFormatter<MultipleOfError>;
+export declare const formatBetweenError: TypeErrorFormatter<BetweenError>;
+export declare const formatArrayError: TypeErrorFormatter<ArrayError>;
+export declare const formatSetError: TypeErrorFormatter<SetError>;
+export declare const formatTupleError: TypeErrorFormatter<TupleError | TupleElementsError<TypeError>>;
+export declare const formatRecordError: TypeErrorFormatter<RecordError>;
+export declare const formatObjectError: TypeErrorFormatter<ObjectError>;
+export declare const formatDiscriminatedUnionError: TypeErrorFormatter<DiscriminatedUnionError>;
+export declare const formatJsonValueError: TypeErrorFormatter<JsonValueError>;
+export declare const formatJsonError: TypeErrorFormatter<JsonError>;
+//# sourceMappingURL=hu.d.ts.map

package/dist/src/intl/hu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hu.d.ts","sourceRoot":"","sources":["../../../src/intl/hu.ts"],"names":[],"mappings":"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"}

package/dist/src/intl/hu.js

@@ -0,0 +1,204 @@
+/**
+ * Hungarian Evolu Type error formatters.
+ *
+ * @module
+ */
+import { assertNonNullable } from "../Assert.js";
+import { safelyStringifyUnknownValue } from "../String.js";
+const formatTypeOfError = (error) => {
+    const typeOf = error.expected.toLowerCase();
+    return `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem ${typeOf}.`;
+};
+const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
+    ? `A(z) ${safelyStringifyUnknownValue(reason.value)} érték nem objektum.`
+    : "Az érték objektum, de az Object Outputnak egyszerű objektumnak kell lennie, vagy null prototípussal kell rendelkeznie.";
+/** Formats a NeverError in Hungarian. */
+export const formatNeverError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes a Never típushoz.`;
+export const formatStringError = formatTypeOfError;
+export const formatTemplateLiteralError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem felel meg a sablonliterálnak.`;
+export const formatNumberError = formatTypeOfError;
+export const formatBigIntError = formatTypeOfError;
+export const formatBooleanError = formatTypeOfError;
+export const formatSymbolError = formatTypeOfError;
+export const formatFunctionError = formatTypeOfError;
+export const formatEvoluTypeError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem Evolu Type.`;
+export const formatObjectTagError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem rendelkezik a várt ${safelyStringifyUnknownValue(error.expected)} objektumcímkével.`;
+export const formatInstanceOfError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem ${error.constructorName} példány.`;
+export const formatLiteralError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem szigorúan egyenlő a várt literállal: ${globalThis.String(error.expected)}.`;
+export const formatUnionError = () => "Az érték nem felel meg egyik engedélyezett változatnak sem.";
+export const formatDateIsoError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem kanonikus ISO dátum-idő karakterlánc.`;
+export const formatDateIsoFromDateError = () => "A Date nem ábrázolható DateIso-ként.";
+export const formatDecimalStringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek kanonikus decimális karakterláncnak kell lennie.`;
+export const formatInt64Error = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes előjeles 64 bites egész szám (Int64).`;
+export const formatUInt64Error = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes előjel nélküli 64 bites egész szám (UInt64).`;
+export const formatInt64StringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes Int64 karakterlánc.`;
+export const formatCapitalizedError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nagybetűvel kell kezdődnie.`;
+export const formatTrimmedError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nem lehetnek kezdő vagy záró szóközei.`;
+export const formatMinLengthError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem éri el a(z) ${error.min} minimális hosszúságot.`;
+export const formatMaxLengthError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték meghaladja a(z) ${error.max} maximális hosszúságot.`;
+export const formatLengthError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek pontosan ${error.exact} hosszúságúnak kell lennie.`;
+export const formatRegexError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem felel meg ennek: /${error.source}/${error.flags}.`;
+export const formatBase64UrlError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes Base64Url karakterlánc.`;
+export const formatNameError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes név.`;
+export const formatMnemonicError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes angol BIP39 mnemonikus kifejezés.`;
+export const formatIdError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes Id.`;
+export const formatTableIdError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem érvényes Id a(z) ${error.table} táblához.`;
+export const formatNonNegativeError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nemnegatívnak kell lennie (>= 0).`;
+export const formatNonNegativeDecimalStringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nemnegatív decimális karakterláncnak kell lennie.`;
+export const formatPositiveError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek pozitívnak kell lennie (> 0).`;
+export const formatPositiveDecimalStringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek pozitív decimális karakterláncnak kell lennie.`;
+export const formatNonPositiveError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nempozitívnak kell lennie (<= 0).`;
+export const formatNonPositiveDecimalStringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nempozitív decimális karakterláncnak kell lennie.`;
+export const formatNegativeError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek negatívnak kell lennie (< 0).`;
+export const formatNegativeDecimalStringError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek negatív decimális karakterláncnak kell lennie.`;
+export const formatIntError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek biztonságos egész számnak kell lennie.`;
+export const formatGreaterThanError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nagyobbnak kell lennie, mint ${error.min}.`;
+export const formatGreaterThanOrEqualToError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek nagyobbnak vagy egyenlőnek kell lennie ${error.min} értéknél.`;
+export const formatLessThanError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek kisebbnek kell lennie, mint ${error.max}.`;
+export const formatLessThanOrEqualToError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek kisebbnek vagy egyenlőnek kell lennie ${error.max} értéknél.`;
+export const formatNonNaNError = () => "Az érték nem lehet NaN.";
+export const formatFiniteError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek végesnek kell lennie.`;
+export const formatMultipleOfError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek ${error.divisor} többszörösének kell lennie.`;
+export const formatBetweenError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} értéknek ${error.min} és ${error.max} között kell lennie, a határokat is beleértve.`;
+export const formatArrayError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `A(z) ${safelyStringifyUnknownValue(error.reason.value)} érték nem tömb.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Hiányzik egy tömbelem a(z) ${issue.index} indexen.`;
+        case "Accessor":
+            return `A(z) ${issue.index} indexen lévő tömbelemnek adat-tulajdonságnak kell lennie.`;
+        case "ExcessProperty":
+            return "Többlet Array-tulajdonság nem engedélyezett. Távolítsa el, vagy használjon másik Type-ot.";
+        case "Element":
+            return `A(z) ${issue.index} indexen lévő tömbelem érvénytelen.`;
+    }
+};
+export const formatSetError = (error) => {
+    if (error.reason.kind === "NotSet") {
+        return `A(z) ${safelyStringifyUnknownValue(error.reason.value)} érték nem Set.`;
+    }
+    if (error.reason.kind === "UnexpectedPrototype") {
+        return "Az érték egy Set-alosztály példánya, de a Set Outputnak közvetlen Set-példánynak kell lennie.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "ExcessProperty":
+            return `A többlet Set-tulajdonság ${safelyStringifyUnknownValue(issue.key)} nem engedélyezett.`;
+        case "Element":
+            return `A(z) ${issue.index} indexen lévő Set-elem érvénytelen.`;
+    }
+};
+export const formatTupleError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `A(z) ${safelyStringifyUnknownValue(error.reason.value)} érték nem tuple.`;
+    }
+    if (error.reason.kind === "InvalidLength") {
+        return `A Tuple-nak pontosan ${error.reason.expected} elemet kell tartalmaznia, de az érték ${error.reason.actual} elemet tartalmaz.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Hiányzik egy Tuple-elem a(z) ${issue.index} indexen.`;
+        case "Accessor":
+            return `A(z) ${issue.index} indexen lévő Tuple-elemnek adat-tulajdonságnak kell lennie.`;
+        case "ExcessProperty":
+            return "Többlet Tuple-tulajdonság nem engedélyezett. Távolítsa el, vagy használjon másik Type-ot.";
+        case "Element":
+            return `A(z) ${issue.index} indexen lévő Tuple-elem érvénytelen.`;
+    }
+};
+export const formatRecordError = (error) => {
+    if (error.reason.kind === "NotRecord") {
+        return `A(z) ${safelyStringifyUnknownValue(error.reason.value)} érték nem Record.`;
+    }
+    if (error.reason.kind === "NotPlainRecord") {
+        return "Az érték objektum, de a Record Outputnak egyszerű objektumnak kell lennie, vagy null prototípussal kell rendelkeznie.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Key":
+            return `A(z) ${safelyStringifyUnknownValue(issue.key)} tulajdonságkulcs érvénytelen.`;
+        case "Value":
+            return `A(z) ${safelyStringifyUnknownValue(issue.key)} tulajdonság értéke érvénytelen.`;
+        case "Accessor":
+            return `A(z) ${safelyStringifyUnknownValue(issue.key)} Record-tulajdonságnak adat-tulajdonságnak kell lennie.`;
+        case "NonEnumerable":
+            return `A(z) ${safelyStringifyUnknownValue(issue.key)} Record-tulajdonságnak felsorolhatónak kell lennie.`;
+        case "Collision":
+            return `A(z) ${safelyStringifyUnknownValue(issue.previousKey)} és ${safelyStringifyUnknownValue(issue.key)} Record-kulcs ugyanarra a(z) ${safelyStringifyUnknownValue(issue.outputKey)} kulcsra dekódolódik.`;
+    }
+};
+export const formatObjectError = (error) => {
+    if (error.reason.kind !== "Properties") {
+        return formatPlainObjectRootError(error.reason);
+    }
+    const key = Reflect.ownKeys(error.reason.errors).at(0);
+    assertNonNullable(key);
+    const propertyError = error.reason.errors[key];
+    assertNonNullable(propertyError);
+    if (propertyError.type === "ObjectPropertyAccess") {
+        switch (propertyError.reason) {
+            case "Accessor":
+                return "Egy Object-tulajdonságnak adat-tulajdonságnak kell lennie. Az accessorértékeket a Type használata előtt alakítsa egyszerű adatokká, vagy használjon másik Type-ot.";
+            case "NonEnumerable":
+                return "Egy Object-tulajdonságnak felsorolhatónak kell lennie. Tegye felsorolhatóvá, vagy használjon másik Type-ot.";
+        }
+    }
+    if (propertyError.type === "ObjectMissingProperty") {
+        return `Hiányzik a kötelező ${safelyStringifyUnknownValue(key)} tulajdonság.`;
+    }
+    if (typeof key === "symbol") {
+        return "Egy Object-tulajdonság kulcsának karakterláncnak kell lennie. Távolítsa el a szimbólumtulajdonságot, vagy használjon másik Type-ot.";
+    }
+    if (propertyError.type === "ObjectExcessProperty") {
+        return `A(z) ${safelyStringifyUnknownValue(key)} tulajdonság nem engedélyezett. Távolítsa el, vagy használjon másik Type-ot.`;
+    }
+    return `A(z) ${safelyStringifyUnknownValue(key)} tulajdonság érvénytelen.`;
+};
+export const formatDiscriminatedUnionError = (error) => {
+    switch (error.reason.kind) {
+        case "Object":
+            return formatPlainObjectRootError(error.reason.error.reason);
+        case "PropertyAccess": {
+            const property = `A(z) ${safelyStringifyUnknownValue(error.reason.key)} diszkriminátor-tulajdonságnak`;
+            if (error.reason.reason === "Accessor") {
+                return `${property} adat-tulajdonságnak kell lennie.`;
+            }
+            if (error.reason.reason === "Inherited") {
+                return `${property} saját tulajdonságnak kell lennie.`;
+            }
+            return `${property} felsorolhatónak kell lennie.`;
+        }
+        case "Discriminator":
+            return `A(z) ${safelyStringifyUnknownValue(error.reason.key)} diszkriminátor-tulajdonság ${safelyStringifyUnknownValue(error.reason.value)} értéke nem várt.`;
+        case "Member":
+            return `A kiválasztott ${safelyStringifyUnknownValue(error.reason.discriminator)} változat érvénytelen.`;
+    }
+};
+export const formatJsonValueError = (error) => {
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "InvalidType":
+            return `A(z) ${safelyStringifyUnknownValue(issue.value)} érték nem JSON-érték.`;
+        case "NonFiniteNumber":
+            return "Egy JSON-számnak végesnek kell lennie.";
+        case "UnexpectedPrototype":
+            return "Az érték objektum, de a JsonValue-objektumnak egyszerű objektumnak kell lennie, vagy null prototípussal kell rendelkeznie.";
+        case "Accessor":
+            return "Egy JSON-tulajdonságnak adat-tulajdonságnak kell lennie. Az accessorértékeket a Type használata előtt alakítsa egyszerű adatokká, vagy használjon másik Type-ot.";
+        case "NonEnumerable":
+            return "Egy JSON-objektumtulajdonságnak felsorolhatónak kell lennie. Távolítsa el, vagy használjon másik Type-ot.";
+        case "SymbolProperty":
+            return "Egy JSON-objektumtulajdonság kulcsának karakterláncnak kell lennie. Távolítsa el a szimbólumtulajdonságot, vagy használjon másik Type-ot.";
+        case "Hole":
+            return "Hiányzik egy JSON-tömbelem.";
+        case "ExcessProperty":
+            return "Többlet JSON-tömbtulajdonság nem engedélyezett. Távolítsa el, vagy használjon másik Type-ot.";
+        case "CircularReference":
+            return "A JsonValue nem tartalmazhat körkörös hivatkozásokat.";
+    }
+};
+export const formatJsonError = (error) => `A(z) ${safelyStringifyUnknownValue(error.value)} érték nem elemezhető JsonValue-vá.`;