@evolu/common 8.1.0 → 8.3.0

package/dist/src/intl/cs.js

@@ -1,11 +1,6 @@
 /**
  * Czech Evolu Type error formatters.
  *
- * Every formatter is exported separately so applications bundle only messages
- * referenced by their localized Type collections. Parameterized Type factories
- * reuse one formatter for every parameter value; for example,
- * {@link formatMinLengthError} formats both `MinLength1` and `MinLength100`.
- *
  * @module
  */
 import { assertNonNullable } from "../Assert.js";
@@ -17,7 +12,9 @@ const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
 /** Formats a NeverError in Czech. */
 export const formatNeverError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} není platná pro typ Never.`;
 /** Formats a String TypeOfError in Czech. */
-export const formatStringError = () => "Hodnota musí být text.";
+export const formatStringError = (error) => formatValueMustBe(error.value, "text");
+/** Formats a TemplateLiteralError in Czech. */
+export const formatTemplateLiteralError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} neodpovídá šablonovému řetězci.`;
 /** Formats a Number TypeOfError in Czech. */
 export const formatNumberError = (error) => formatValueMustBe(error.value, "číslo");
 /** Formats a BigInt TypeOfError in Czech. */
@@ -28,6 +25,8 @@ export const formatBooleanError = (error) => formatValueMustBe(error.value, "log
 export const formatSymbolError = (error) => formatValueMustBe(error.value, "symbol");
 /** Formats a Function TypeOfError in Czech. */
 export const formatFunctionError = (error) => formatValueMustBe(error.value, "funkce");
+/** Formats an EvoluTypeError in Czech. */
+export const formatEvoluTypeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být Evolu Type.`;
 /** Formats an ObjectTagError in Czech. */
 export const formatObjectTagError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} nemá očekávaný tag objektu ${safelyStringifyUnknownValue(error.expected)}.`;
 /** Formats an InstanceOfError in Czech. */
@@ -37,13 +36,19 @@ export const formatLiteralError = (error) => `Hodnota ${safelyStringifyUnknownVa
 /** Formats a UnionError in Czech. */
 export const formatUnionError = () => "Hodnota neodpovídá žádné z povolených variant.";
 /** Formats a DateIsoError in Czech. */
-export const formatDateIsoError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být datum a čas v kanonickém formátu ISO.`;
+export const formatDateIsoError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být řetězec s datem a časem v kanonickém formátu ISO.`;
+/** Formats a DateIsoFromDateError in Czech. */
+export const formatDateIsoFromDateError = () => "Datum nelze převést na DateIso.";
+/** Formats a DecimalStringError in Czech. */
+export const formatDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být kanonický řetězec představující desetinné číslo.`;
 /** Formats an Int64Error in Czech. */
 export const formatInt64Error = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platné 64bitové celé číslo se znaménkem (Int64).`;
 /** Formats a UInt64Error in Czech. */
 export const formatUInt64Error = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platné 64bitové celé číslo bez znaménka (UInt64).`;
+/** Formats an Int64StringError in Czech. */
+export const formatInt64StringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platný řetězec Int64.`;
 /** Formats a CapitalizedError in Czech. */
-export const formatCapitalizedError = (error) => `Text ${safelyStringifyUnknownValue(error.value)} musí začínat velkým písmenem.`;
+export const formatCapitalizedError = (error) => `Text ${safelyStringifyUnknownValue(error.value)} musí být kapitalizován.`;
 /** Formats a TrimmedError in Czech. */
 export const formatTrimmedError = (error) => `Text ${safelyStringifyUnknownValue(error.value)} nesmí obsahovat bílé znaky na začátku ani na konci.`;
 /** Formats a MinLengthError in Czech. */
@@ -56,16 +61,32 @@ export const formatMaxLengthError = (error) => `Hodnota ${safelyStringifyUnknown
 export const formatLengthError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí mít délku přesně ${error.exact}.`;
 /** Formats a RegexError in Czech. */
 export const formatRegexError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} neodpovídá regulárnímu výrazu /${error.source}/${error.flags}.`;
+/** Formats a Base64UrlError in Czech. */
+export const formatBase64UrlError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platný řetězec Base64Url.`;
+/** Formats a NameError in Czech. */
+export const formatNameError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platný název.`;
+/** Formats a MnemonicError in Czech. */
+export const formatMnemonicError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platná anglická BIP39 mnemotechnická fráze.`;
+/** Formats an IdError in Czech. */
+export const formatIdError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platné Id.`;
+/** Formats a TableIdError in Czech. */
+export const formatTableIdError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být platné Id pro tabulku ${safelyStringifyUnknownValue(error.table)}.`;
 /** Formats a NonNegativeError in Czech. */
 export const formatNonNegativeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být nezáporná (>= 0).`;
+/** Formats a NonNegativeDecimalStringError in Czech. */
+export const formatNonNegativeDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být řetězec představující nezáporné desetinné číslo.`;
 /** Formats a PositiveError in Czech. */
 export const formatPositiveError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být kladná (> 0).`;
 /** Formats a PositiveDecimalStringError in Czech. */
-export const formatPositiveDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být kanonický řetězec představující kladné desetinné číslo.`;
+export const formatPositiveDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být řetězec představující kladné desetinné číslo.`;
 /** Formats a NonPositiveError in Czech. */
 export const formatNonPositiveError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být nekladná (<= 0).`;
+/** Formats a NonPositiveDecimalStringError in Czech. */
+export const formatNonPositiveDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být řetězec představující nekladné desetinné číslo.`;
 /** Formats a NegativeError in Czech. */
 export const formatNegativeError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být záporná (< 0).`;
+/** Formats a NegativeDecimalStringError in Czech. */
+export const formatNegativeDecimalStringError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být řetězec představující záporné desetinné číslo.`;
 /** Formats an IntError in Czech. */
 export const formatIntError = (error) => `Hodnota ${safelyStringifyUnknownValue(error.value)} musí být bezpečné celé číslo.`;
 /** Formats a GreaterThanError in Czech. */
@@ -101,13 +122,29 @@ export const formatArrayError = (error) => {
             return `Prvek pole na indexu ${issue.index} není platný.`;
     }
 };
+/** Formats a SetError in Czech. */
+export const formatSetError = (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) {
+        case "ExcessProperty":
+            return `Set obsahuje nepovolenou vlastní vlastnost ${safelyStringifyUnknownValue(issue.key)}.`;
+        case "Element":
+            return `Prvek Setu na indexu ${issue.index} není platný.`;
+    }
+};
 /** Formats a TupleError in Czech. */
 export const formatTupleError = (error) => {
     if (error.reason.kind === "NotArray") {
         return `Hodnota ${safelyStringifyUnknownValue(error.reason.value)} není tuple.`;
     }
     if (error.reason.kind === "InvalidLength") {
-        return `Požadovaná délka Tuple je ${error.reason.expected}, ale hodnota má délku ${error.reason.actual}.`;
+        return `Tuple musí mít délku ${error.reason.expected}, ale hodnota má délku ${error.reason.actual}.`;
     }
     const issue = error.reason.issues[0];
     switch (issue.kind) {
@@ -136,11 +173,11 @@ export const formatRecordError = (error) => {
         case "Value":
             return `Hodnota vlastnosti ${safelyStringifyUnknownValue(issue.key)} není platná.`;
         case "Accessor":
-            return `Vlastnost Record ${safelyStringifyUnknownValue(issue.key)} musí být datová vlastnost.`;
+            return `Vlastnost Recordu ${safelyStringifyUnknownValue(issue.key)} musí být datová vlastnost.`;
         case "NonEnumerable":
-            return `Vlastnost Record ${safelyStringifyUnknownValue(issue.key)} musí být enumerable.`;
+            return `Vlastnost Recordu ${safelyStringifyUnknownValue(issue.key)} musí být enumerovatelná (enumerable).`;
         case "Collision":
-            return `Klíče Record ${safelyStringifyUnknownValue(issue.previousKey)} a ${safelyStringifyUnknownValue(issue.key)} se dekódují na stejný klíč ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+            return `Klíče Recordu ${safelyStringifyUnknownValue(issue.previousKey)} a ${safelyStringifyUnknownValue(issue.key)} se dekódují na stejný klíč ${safelyStringifyUnknownValue(issue.outputKey)}.`;
     }
 };
 /** Formats an ObjectError in Czech. */
@@ -155,20 +192,20 @@ export const formatObjectError = (error) => {
     if (propertyError.type === "ObjectPropertyAccess") {
         switch (propertyError.reason) {
             case "Accessor":
-                return "Vlastnost Object musí být datová vlastnost. Před použitím tohoto Type materializujte hodnotu accessoru do prostých dat nebo použijte jiný Type.";
+                return "Vlastnost typu Object musí být datová vlastnost. Před použitím tohoto Type materializujte hodnotu accessoru do prostých dat nebo použijte jiný Type.";
             case "NonEnumerable":
-                return "Vlastnost Object musí být enumerable.";
+                return "Vlastnost typu Object musí být enumerovatelná (enumerable).";
         }
     }
     if (propertyError.type === "ObjectMissingProperty") {
         return `Povinná vlastnost ${safelyStringifyUnknownValue(key)} chybí.`;
     }
+    if (typeof key === "symbol") {
+        return "Klíč vlastnosti typu Object musí být text. Odstraňte symbolovou vlastnost nebo použijte jiný Type.";
+    }
     if (propertyError.type === "ObjectExcessProperty") {
         return `Vlastnost ${safelyStringifyUnknownValue(key)} není povolena. Odstraňte ji nebo použijte jiný Type.`;
     }
-    if (propertyError.type === "TypeOf" && typeof key === "symbol") {
-        return "Klíč vlastnosti Object musí být text. Odstraňte symbolovou vlastnost nebo použijte jiný Type.";
-    }
     return `Vlastnost ${safelyStringifyUnknownValue(key)} není platná.`;
 };
 /** Formats a DiscriminatedUnionError in Czech. */
@@ -177,17 +214,17 @@ export const formatDiscriminatedUnionError = (error) => {
         case "Object":
             return formatPlainObjectRootError(error.reason.error.reason);
         case "PropertyAccess": {
-            const property = `Diskriminační vlastnost ${safelyStringifyUnknownValue(error.reason.key)}`;
+            const property = `Rozlišovací vlastnost ${safelyStringifyUnknownValue(error.reason.key)}`;
             if (error.reason.reason === "Accessor") {
                 return `${property} musí být datová vlastnost.`;
             }
             if (error.reason.reason === "Inherited") {
                 return `${property} musí být vlastní vlastnost.`;
             }
-            return `${property} musí být enumerable.`;
+            return `${property} musí být enumerovatelná (enumerable).`;
         }
         case "Discriminator":
-            return `Diskriminační vlastnost ${safelyStringifyUnknownValue(error.reason.key)} má neočekávanou hodnotu ${safelyStringifyUnknownValue(error.reason.value)}.`;
+            return `Rozlišovací vlastnost ${safelyStringifyUnknownValue(error.reason.key)} má neočekávanou hodnotu ${safelyStringifyUnknownValue(error.reason.value)}.`;
         case "Member":
             return `Vybraná varianta ${safelyStringifyUnknownValue(error.reason.discriminator)} není platná.`;
     }
@@ -201,20 +238,20 @@ export const formatJsonValueError = (error) => {
         case "NonFiniteNumber":
             return "Číslo v JSON musí být konečné.";
         case "UnexpectedPrototype":
-            return "Hodnota je objekt, ale JsonValue Object musí být prostý objekt nebo mít prototyp null.";
+            return "Hodnota je objekt, ale objekt v JsonValue musí být prostý objekt nebo mít prototyp null.";
         case "Accessor":
-            return "Vlastnost JSON musí být datová vlastnost. Před použitím tohoto Type materializujte hodnotu accessoru do prostých dat nebo použijte jiný Type.";
+            return "Vlastnost objektu JSON musí být datová vlastnost. Před použitím tohoto Type materializujte hodnotu accessoru do prostých dat nebo použijte jiný Type.";
         case "NonEnumerable":
-            return "Vlastnost JSON Object musí být enumerable. Odstraňte ji nebo použijte jiný Type.";
+            return "Vlastnost objektu JSON musí být enumerovatelná (enumerable). Odstraňte ji nebo použijte jiný Type.";
         case "SymbolProperty":
-            return "Klíč vlastnosti JSON Object musí být text. Odstraňte symbolovou vlastnost nebo použijte jiný Type.";
+            return "Klíč vlastnosti objektu JSON musí být text. Odstraňte symbolovou vlastnost nebo použijte jiný Type.";
         case "Hole":
-            return "V JSON Array chybí prvek.";
+            return "V poli JSON chybí prvek.";
         case "ExcessProperty":
-            return "JSON Array obsahuje nepovolenou vlastní vlastnost. Odstraňte ji nebo použijte jiný Type.";
+            return "Pole JSON obsahuje nepovolenou vlastní vlastnost. Odstraňte ji nebo použijte jiný Type.";
         case "CircularReference":
             return "JsonValue nesmí obsahovat cyklické reference.";
     }
 };
 /** Formats a JsonError in Czech. */
-export const formatJsonError = (error) => `Hodnotu ${safelyStringifyUnknownValue(error.value)} nelze převést na JsonValue.`;
+export const formatJsonError = (error) => `Hodnotu ${safelyStringifyUnknownValue(error.value)} nelze parsovat jako JsonValue.`;

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

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

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

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

package/dist/src/intl/da.js

@@ -0,0 +1,258 @@
+/**
+ * Danske fejlformaterere til Evolu Type.
+ *
+ * @module
+ */
+import { assertNonNullable } from "../Assert.js";
+import { safelyStringifyUnknownValue } from "../String.js";
+const formatTypeOfError = (error) => {
+    const typeOf = error.expected.toLowerCase();
+    return `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke af typen ${typeOf}.`;
+};
+const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
+    ? `Værdien ${safelyStringifyUnknownValue(reason.value)} er ikke et objekt.`
+    : "Værdien er et objekt, men et Object Output skal være et almindeligt objekt eller have en null-prototype.";
+/** Formaterer NeverError på dansk. */
+export const formatNeverError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke gyldig for typen Never.`;
+/** Formaterer String TypeOfError på dansk. */
+export const formatStringError = formatTypeOfError;
+/** Formaterer TemplateLiteralError på dansk. */
+export const formatTemplateLiteralError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} matcher ikke skabelonliteralen.`;
+/** Formaterer Number TypeOfError på dansk. */
+export const formatNumberError = formatTypeOfError;
+/** Formaterer BigInt TypeOfError på dansk. */
+export const formatBigIntError = formatTypeOfError;
+/** Formaterer Boolean TypeOfError på dansk. */
+export const formatBooleanError = formatTypeOfError;
+/** Formaterer Symbol TypeOfError på dansk. */
+export const formatSymbolError = formatTypeOfError;
+/** Formaterer Function TypeOfError på dansk. */
+export const formatFunctionError = formatTypeOfError;
+/** Formaterer EvoluTypeError på dansk. */
+export const formatEvoluTypeError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en Evolu Type.`;
+/** Formaterer ObjectTagError på dansk. */
+export const formatObjectTagError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} har ikke det forventede objekt-tag ${safelyStringifyUnknownValue(error.expected)}.`;
+/** Formaterer InstanceOfError på dansk. */
+export const formatInstanceOfError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en instans af ${error.constructorName}.`;
+/** Formaterer LiteralError på dansk. */
+export const formatLiteralError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke strengt lig med den forventede literalværdi: ${globalThis.String(error.expected)}.`;
+/** Formaterer UnionError på dansk. */
+export const formatUnionError = () => "Værdien matcher ingen af de tilladte varianter.";
+/** Formaterer DateIsoError på dansk. */
+export const formatDateIsoError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en kanonisk ISO-dato- og tidsstreng.`;
+/** Formaterer DateIsoFromDateError på dansk. */
+export const formatDateIsoFromDateError = () => "Date-værdien kan ikke repræsenteres som DateIso.";
+/** Formaterer DecimalStringError på dansk. */
+export const formatDecimalStringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være en kanonisk decimalstreng.`;
+/** Formaterer Int64Error på dansk. */
+export const formatInt64Error = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke et gyldigt 64-bit heltal med fortegn (Int64).`;
+/** Formaterer UInt64Error på dansk. */
+export const formatUInt64Error = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke et gyldigt 64-bit heltal uden fortegn (UInt64).`;
+/** Formaterer Int64StringError på dansk. */
+export const formatInt64StringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en gyldig Int64-streng.`;
+/** Formaterer CapitalizedError på dansk. */
+export const formatCapitalizedError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal begynde med stort bogstav.`;
+/** Formaterer TrimmedError på dansk. */
+export const formatTrimmedError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være trimmet.`;
+/** Formaterer MinLengthError på dansk. */
+export const formatMinLengthError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} opfylder ikke minimumslængden på ${error.min}.`;
+/** Formaterer MaxLengthError på dansk. */
+export const formatMaxLengthError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} overskrider maksimumslængden på ${error.max}.`;
+/** Formaterer LengthError på dansk. */
+export const formatLengthError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} har ikke den krævede længde på ${error.exact}.`;
+/** Formaterer RegexError på dansk. */
+export const formatRegexError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} matcher ikke /${error.source}/${error.flags}.`;
+/** Formaterer Base64UrlError på dansk. */
+export const formatBase64UrlError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en gyldig Base64Url-streng.`;
+/** Formaterer NameError på dansk. */
+export const formatNameError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke et gyldigt Name.`;
+/** Formaterer MnemonicError på dansk. */
+export const formatMnemonicError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke en gyldig engelsk BIP39-mnemonic.`;
+/** Formaterer IdError på dansk. */
+export const formatIdError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke et gyldigt Id.`;
+/** Formaterer TableIdError på dansk. */
+export const formatTableIdError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} er ikke et gyldigt Id for tabellen ${error.table}.`;
+/** Formaterer NonNegativeError på dansk. */
+export const formatNonNegativeError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være ikke-negativ (>= 0).`;
+/** Formaterer NonNegativeDecimalStringError på dansk. */
+export const formatNonNegativeDecimalStringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være en ikke-negativ decimalstreng.`;
+/** Formaterer PositiveError på dansk. */
+export const formatPositiveError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være positiv (> 0).`;
+/** Formaterer PositiveDecimalStringError på dansk. */
+export const formatPositiveDecimalStringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være en positiv decimalstreng.`;
+/** Formaterer NonPositiveError på dansk. */
+export const formatNonPositiveError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være ikke-positiv (<= 0).`;
+/** Formaterer NonPositiveDecimalStringError på dansk. */
+export const formatNonPositiveDecimalStringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være en ikke-positiv decimalstreng.`;
+/** Formaterer NegativeError på dansk. */
+export const formatNegativeError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være negativ (< 0).`;
+/** Formaterer NegativeDecimalStringError på dansk. */
+export const formatNegativeDecimalStringError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være en negativ decimalstreng.`;
+/** Formaterer IntError på dansk. */
+export const formatIntError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være et sikkert heltal.`;
+/** Formaterer GreaterThanError på dansk. */
+export const formatGreaterThanError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være større end ${error.min}.`;
+/** Formaterer GreaterThanOrEqualToError på dansk. */
+export const formatGreaterThanOrEqualToError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være større end eller lig med ${error.min}.`;
+/** Formaterer LessThanError på dansk. */
+export const formatLessThanError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være mindre end ${error.max}.`;
+/** Formaterer LessThanOrEqualToError på dansk. */
+export const formatLessThanOrEqualToError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være mindre end eller lig med ${error.max}.`;
+/** Formaterer NonNaNError på dansk. */
+export const formatNonNaNError = () => "Værdien må ikke være NaN.";
+/** Formaterer FiniteError på dansk. */
+export const formatFiniteError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være endelig.`;
+/** Formaterer MultipleOfError på dansk. */
+export const formatMultipleOfError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være et multiplum af ${error.divisor}.`;
+/** Formaterer BetweenError på dansk. */
+export const formatBetweenError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} skal være mellem ${error.min} og ${error.max}, inklusive.`;
+/** Formaterer ArrayError på dansk. */
+export const formatArrayError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Værdien ${safelyStringifyUnknownValue(error.reason.value)} er ikke et array.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Et array-element på indeks ${issue.index} mangler.`;
+        case "Accessor":
+            return `Et array-element på indeks ${issue.index} skal være en dataegenskab.`;
+        case "ExcessProperty":
+            return "En ekstra Array-egenskab er ikke tilladt. Fjern den, eller brug en anden Type.";
+        case "Element":
+            return `Et array-element på indeks ${issue.index} er ugyldigt.`;
+    }
+};
+/** Formaterer SetError på dansk. */
+export const formatSetError = (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) {
+        case "ExcessProperty":
+            return `Den ekstra Set-egenskab ${safelyStringifyUnknownValue(issue.key)} er ikke tilladt.`;
+        case "Element":
+            return `Et Set-element på indeks ${issue.index} er ugyldigt.`;
+    }
+};
+/** Formaterer TupleError på dansk. */
+export const formatTupleError = (error) => {
+    if (error.reason.kind === "NotArray") {
+        return `Værdien ${safelyStringifyUnknownValue(error.reason.value)} er ikke en tuple.`;
+    }
+    if (error.reason.kind === "InvalidLength") {
+        return `En Tuple skal indeholde præcis ${error.reason.expected} elementer, men værdien indeholder ${error.reason.actual}.`;
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Hole":
+            return `Et Tuple-element på indeks ${issue.index} mangler.`;
+        case "Accessor":
+            return `Et Tuple-element på indeks ${issue.index} skal være en dataegenskab.`;
+        case "ExcessProperty":
+            return "En ekstra Tuple-egenskab er ikke tilladt. Fjern den, eller brug en anden Type.";
+        case "Element":
+            return `Et Tuple-element på indeks ${issue.index} er ugyldigt.`;
+    }
+};
+/** Formaterer RecordError på dansk. */
+export const formatRecordError = (error) => {
+    if (error.reason.kind === "NotRecord") {
+        return `Værdien ${safelyStringifyUnknownValue(error.reason.value)} er ikke en Record.`;
+    }
+    if (error.reason.kind === "NotPlainRecord") {
+        return "Værdien er et objekt, men et Record Output skal være et almindeligt objekt eller have en null-prototype.";
+    }
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "Key":
+            return `Egenskabsnøglen ${safelyStringifyUnknownValue(issue.key)} er ugyldig.`;
+        case "Value":
+            return `Værdien af egenskaben ${safelyStringifyUnknownValue(issue.key)} er ugyldig.`;
+        case "Accessor":
+            return `Record-egenskaben ${safelyStringifyUnknownValue(issue.key)} skal være en dataegenskab.`;
+        case "NonEnumerable":
+            return `Record-egenskaben ${safelyStringifyUnknownValue(issue.key)} skal være enumererbar.`;
+        case "Collision":
+            return `Record-nøglerne ${safelyStringifyUnknownValue(issue.previousKey)} og ${safelyStringifyUnknownValue(issue.key)} afkodes til den samme nøgle ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+    }
+};
+/** Formaterer ObjectError på dansk. */
+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 "En Object-egenskab skal være en dataegenskab. Materialiser accessor-værdier som almindelige data, før denne Type bruges, eller brug en anden Type.";
+            case "NonEnumerable":
+                return "En Object-egenskab skal være enumererbar. Gør den enumererbar, eller brug en anden Type.";
+        }
+    }
+    if (propertyError.type === "ObjectMissingProperty") {
+        return `Den påkrævede egenskab ${safelyStringifyUnknownValue(key)} mangler.`;
+    }
+    if (typeof key === "symbol") {
+        return "En Object-egenskabsnøgle skal være en streng. Fjern symbol-egenskaben, eller brug en anden Type.";
+    }
+    if (propertyError.type === "ObjectExcessProperty") {
+        return `Egenskaben ${safelyStringifyUnknownValue(key)} er ikke tilladt. Fjern den, eller brug en anden Type.`;
+    }
+    return `Egenskaben ${safelyStringifyUnknownValue(key)} er ugyldig.`;
+};
+/** Formaterer DiscriminatedUnionError på dansk. */
+export const formatDiscriminatedUnionError = (error) => {
+    switch (error.reason.kind) {
+        case "Object":
+            return formatPlainObjectRootError(error.reason.error.reason);
+        case "PropertyAccess": {
+            const property = `Diskriminatoregenskaben ${safelyStringifyUnknownValue(error.reason.key)}`;
+            if (error.reason.reason === "Accessor") {
+                return `${property} skal være en dataegenskab.`;
+            }
+            if (error.reason.reason === "Inherited") {
+                return `${property} skal være en egen egenskab.`;
+            }
+            return `${property} skal være enumererbar.`;
+        }
+        case "Discriminator":
+            return `Diskriminatoregenskaben ${safelyStringifyUnknownValue(error.reason.key)} has an unexpected value ${safelyStringifyUnknownValue(error.reason.value)}.`;
+        case "Member":
+            return `Den valgte variant ${safelyStringifyUnknownValue(error.reason.discriminator)} er ugyldig.`;
+    }
+};
+/** Formaterer JsonValueError på dansk. */
+export const formatJsonValueError = (error) => {
+    const issue = error.reason.issues[0];
+    switch (issue.kind) {
+        case "InvalidType":
+            return `Værdien ${safelyStringifyUnknownValue(issue.value)} er ikke en JSON-værdi.`;
+        case "NonFiniteNumber":
+            return "Et JSON-tal skal være endeligt.";
+        case "UnexpectedPrototype":
+            return "Værdien er et objekt, men et JsonValue-objekt skal være et almindeligt objekt eller have en null-prototype.";
+        case "Accessor":
+            return "En JSON-egenskab skal være en dataegenskab. Materialiser accessor-værdier som almindelige data, før denne Type bruges, eller brug en anden Type.";
+        case "NonEnumerable":
+            return "En JSON-objektegenskab skal være enumererbar. Fjern den, eller brug en anden Type.";
+        case "SymbolProperty":
+            return "En JSON-objektegenskabsnøgle skal være en streng. Fjern symbol-egenskaben, eller brug en anden Type.";
+        case "Hole":
+            return "Et JSON-array-element mangler.";
+        case "ExcessProperty":
+            return "En ekstra JSON-array-egenskab er ikke tilladt. Fjern den, eller brug en anden Type.";
+        case "CircularReference":
+            return "En JsonValue må ikke indeholde cirkulære referencer.";
+    }
+};
+/** Formaterer JsonError på dansk. */
+export const formatJsonError = (error) => `Værdien ${safelyStringifyUnknownValue(error.value)} kan ikke parses til en JsonValue.`;