@openclaw/discord 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/system/hashing/hash.mjs

@@ -0,0 +1,232 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../unreachable/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// InstanceKeys
+//
+// Retrieves all enumerable and non-enumerable own property keys 
+// and inherited prototype keys (excluding symbols and the 'constructor') 
+// from an object instance.
+//
+// This function is useful for differentiating between class instances 
+// based on their structural keys rather than relying on the 
+// constructor name. It provides a more reliable structural comparison 
+// by capturing both own and prototype properties.
+//
+// ------------------------------------------------------------------
+function InstanceKeys(value) {
+    const propertyKeys = new Set();
+    let current = value;
+    while (current && current !== Object.prototype) {
+        for (const key of Reflect.ownKeys(current)) {
+            if (key !== 'constructor' && typeof key !== 'symbol')
+                propertyKeys.add(key);
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return [...propertyKeys];
+}
+// ------------------------------------------------------------------
+// IsIEEE754
+//
+// TypeBox guards do not consider +/- Infinity or NaN as valid
+// numbers, but they are valid IEEE754 numbers. We use a special
+// guard to ensure these numbers are considered for hashing.
+//
+// ------------------------------------------------------------------
+function IsIEEE754(value) {
+    return typeof value === 'number';
+}
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Array"] = 0] = "Array";
+    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Date"] = 3] = "Date";
+    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+    ByteMarker[ByteMarker["Function"] = 5] = "Function";
+    ByteMarker[ByteMarker["Null"] = 6] = "Null";
+    ByteMarker[ByteMarker["Number"] = 7] = "Number";
+    ByteMarker[ByteMarker["Object"] = 8] = "Object";
+    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+    ByteMarker[ByteMarker["String"] = 10] = "String";
+    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const F64Out = new Uint8Array(F64.buffer);
+// ------------------------------------------------------------------
+// Operation
+// ------------------------------------------------------------------
+function FNV1A64_OP(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    FNV1A64_OP(ByteMarker.Array);
+    for (const item of value) {
+        FromValue(item);
+    }
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    FNV1A64_OP(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    FNV1A64_OP(ByteMarker.Boolean);
+    FNV1A64_OP(value ? 1 : 0);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+function FromConstructor(value) {
+    FNV1A64_OP(ByteMarker.Constructor);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+function FromDate(value) {
+    FNV1A64_OP(ByteMarker.Date);
+    FromValue(value.getTime());
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+function FromFunction(value) {
+    FNV1A64_OP(ByteMarker.Function);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(_value) {
+    FNV1A64_OP(ByteMarker.Null);
+}
+// ------------------------------------------------------------------
+// Number | IEEE754
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    FNV1A64_OP(ByteMarker.Number);
+    F64In.setFloat64(0, value, true /* little-endian */);
+    for (const byte of F64Out) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    FNV1A64_OP(ByteMarker.Object);
+    for (const key of InstanceKeys(value).sort()) {
+        FromValue(key);
+        FromValue(value[key]);
+    }
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    FNV1A64_OP(ByteMarker.RegExp);
+    FromString(value.toString());
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+const encoder = new TextEncoder();
+function FromString(value) {
+    FNV1A64_OP(ByteMarker.String);
+    for (const byte of encoder.encode(value)) {
+        FNV1A64_OP(byte);
+    }
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+function FromSymbol(value) {
+    FNV1A64_OP(ByteMarker.Symbol);
+    FromValue(value.toString());
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypeArray(value) {
+    FNV1A64_OP(ByteMarker.TypeArray);
+    const buffer = new Uint8Array(value.buffer);
+    for (let i = 0; i < buffer.length; i++) {
+        FNV1A64_OP(buffer[i]);
+    }
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(_value) {
+    return FNV1A64_OP(ByteMarker.Undefined);
+}
+// ------------------------------------------------------------------
+// Hash
+//
+// deno-coverage-ignore-start - unreachable
+//
+// This function should all JavaScript values so we can't reach the
+// fall-through. We use Unreachable to assert that no values pass
+// through. We will need to handle these should they arise.
+//
+// ------------------------------------------------------------------
+function FromValue(value) {
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypeArray(value) :
+        GlobalsGuard.IsDate(value) ? FromDate(value) :
+            GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+                GlobalsGuard.IsBoolean(value) ? FromBoolean(value.valueOf()) :
+                    GlobalsGuard.IsString(value) ? FromString(value.valueOf()) :
+                        GlobalsGuard.IsNumber(value) ? FromNumber(value.valueOf()) :
+                            IsIEEE754(value) ? FromNumber(value) :
+                                Guard.IsArray(value) ? FromArray(value) :
+                                    Guard.IsBoolean(value) ? FromBoolean(value) :
+                                        Guard.IsBigInt(value) ? FromBigInt(value) :
+                                            Guard.IsConstructor(value) ? FromConstructor(value) :
+                                                Guard.IsNull(value) ? FromNull(value) :
+                                                    Guard.IsObject(value) ? FromObject(value) :
+                                                        Guard.IsString(value) ? FromString(value) :
+                                                            Guard.IsSymbol(value) ? FromSymbol(value) :
+                                                                Guard.IsUndefined(value) ? FromUndefined(value) :
+                                                                    Guard.IsFunction(value) ? FromFunction(value) :
+                                                                        Unreachable());
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export function HashCode(value) {
+    Accumulator = BigInt('14695981039346656037');
+    FromValue(value);
+    return Accumulator;
+}
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export function Hash(value) {
+    return HashCode(value).toString(16).padStart(16, '0');
+}

package/node_modules/typebox/build/system/hashing/index.d.mts

@@ -0,0 +1 @@
+export * as Hashing from './hash.mjs';

package/node_modules/typebox/build/system/hashing/index.mjs

@@ -0,0 +1 @@
+export * as Hashing from './hash.mjs';

package/node_modules/typebox/build/system/index.d.mts

@@ -0,0 +1,4 @@
+export * from './system.mjs';
+export * as System from './system.mjs';
+import * as System from './system.mjs';
+export default System;

package/node_modules/typebox/build/system/index.mjs

@@ -0,0 +1,4 @@
+export * from './system.mjs';
+export * as System from './system.mjs';
+import * as System from './system.mjs';
+export default System;

package/node_modules/typebox/build/system/locale/_config.d.mts

@@ -0,0 +1,7 @@
+import { type TLocalizedValidationMessageCallback } from '../../error/index.mjs';
+/** Sets the locale */
+export declare function Set(callback: TLocalizedValidationMessageCallback): void;
+/** Gets the locale */
+export declare function Get(): TLocalizedValidationMessageCallback;
+/** Resets the locale to `en_US` */
+export declare function Reset(): void;

package/node_modules/typebox/build/system/locale/_config.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { en_US } from './en_US.mjs';
+let locale = en_US;
+/** Sets the locale */
+export function Set(callback) {
+    locale = callback;
+}
+/** Gets the locale */
+export function Get() {
+    return locale;
+}
+/** Resets the locale to `en_US` */
+export function Reset() {
+    Set(en_US);
+}

package/node_modules/typebox/build/system/locale/_locale.d.mts

@@ -0,0 +1,40 @@
+export * from './_config.mjs';
+export * from './ar_001.mjs';
+export * from './bn_BD.mjs';
+export * from './cs_CZ.mjs';
+export * from './de_DE.mjs';
+export * from './el_GR.mjs';
+export * from './en_US.mjs';
+export * from './es_419.mjs';
+export * from './es_AR.mjs';
+export * from './es_ES.mjs';
+export * from './es_MX.mjs';
+export * from './fa_IR.mjs';
+export * from './fil_PH.mjs';
+export * from './fr_CA.mjs';
+export * from './fr_CA.mjs';
+export * from './fr_FR.mjs';
+export * from './ha_NG.mjs';
+export * from './hi_IN.mjs';
+export * from './hu_HU.mjs';
+export * from './id_ID.mjs';
+export * from './it_IT.mjs';
+export * from './ja_JP.mjs';
+export * from './ko_KR.mjs';
+export * from './ms_MY.mjs';
+export * from './nl_NL.mjs';
+export * from './pl_PL.mjs';
+export * from './pt_BR.mjs';
+export * from './pt_PT.mjs';
+export * from './ro_RO.mjs';
+export * from './ru_RU.mjs';
+export * from './sv_SE.mjs';
+export * from './sw_TZ.mjs';
+export * from './th_TH.mjs';
+export * from './tr_TR.mjs';
+export * from './uk_UA.mjs';
+export * from './ur_PK.mjs';
+export * from './vi_VN.mjs';
+export * from './yo_NG.mjs';
+export * from './zh_Hans.mjs';
+export * from './zh_Hant.mjs';

package/node_modules/typebox/build/system/locale/_locale.mjs

@@ -0,0 +1,40 @@
+export * from './_config.mjs';
+export * from './ar_001.mjs';
+export * from './bn_BD.mjs';
+export * from './cs_CZ.mjs';
+export * from './de_DE.mjs';
+export * from './el_GR.mjs';
+export * from './en_US.mjs';
+export * from './es_419.mjs';
+export * from './es_AR.mjs';
+export * from './es_ES.mjs';
+export * from './es_MX.mjs';
+export * from './fa_IR.mjs';
+export * from './fil_PH.mjs';
+export * from './fr_CA.mjs';
+export * from './fr_CA.mjs';
+export * from './fr_FR.mjs';
+export * from './ha_NG.mjs';
+export * from './hi_IN.mjs';
+export * from './hu_HU.mjs';
+export * from './id_ID.mjs';
+export * from './it_IT.mjs';
+export * from './ja_JP.mjs';
+export * from './ko_KR.mjs';
+export * from './ms_MY.mjs';
+export * from './nl_NL.mjs';
+export * from './pl_PL.mjs';
+export * from './pt_BR.mjs';
+export * from './pt_PT.mjs';
+export * from './ro_RO.mjs';
+export * from './ru_RU.mjs';
+export * from './sv_SE.mjs';
+export * from './sw_TZ.mjs';
+export * from './th_TH.mjs';
+export * from './tr_TR.mjs';
+export * from './uk_UA.mjs';
+export * from './ur_PK.mjs';
+export * from './vi_VN.mjs';
+export * from './yo_NG.mjs';
+export * from './zh_Hans.mjs';
+export * from './zh_Hant.mjs';

package/node_modules/typebox/build/system/locale/ar_001.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Arabic (World) - ISO 639-1 language code 'ar' with UN M.49 region code '001' for World. */
+export declare function ar_001(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/ar_001.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Arabic (World) - ISO 639-1 language code 'ar' with UN M.49 region code '001' for World. */
+export function ar_001(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'يجب ألا يحتوي على خصائص إضافية';
+        case 'anyOf': return 'يجب أن يتطابق مع مخطط في أيٍ مما يلي';
+        case 'boolean': return 'المخطط خاطئ';
+        case 'const': return 'يجب أن يكون مساويًا للثابت';
+        case 'contains': return 'يجب أن يحتوي على عنصر واحد صحيح على الأقل';
+        case 'dependencies': return `يجب أن يحتوي على الخصائص ${error.params.dependencies.join(', ')} عندما تكون الخاصية ${error.params.property} موجودة`;
+        case 'dependentRequired': return `يجب أن يحتوي على الخصائص ${error.params.dependencies.join(', ')} عندما تكون الخاصية ${error.params.property} موجودة`;
+        case 'enum': return 'يجب أن يكون مساويًا لإحدى القيم المسموح بها';
+        case 'exclusiveMaximum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `يجب أن يتطابق مع التنسيق "${error.params.format}"`;
+        case 'if': return `يجب أن يتطابق مع مخطط "${error.params.failingKeyword}"`;
+        case 'maxItems': return `يجب ألا يحتوي على أكثر من ${error.params.limit} عناصر`;
+        case 'maxLength': return `يجب ألا يحتوي على أكثر من ${error.params.limit} أحرف`;
+        case 'maxProperties': return `يجب ألا يحتوي على أكثر من ${error.params.limit} خصائص`;
+        case 'maximum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `يجب ألا يحتوي على أقل من ${error.params.limit} عناصر`;
+        case 'minLength': return `يجب ألا يحتوي على أقل من ${error.params.limit} أحرف`;
+        case 'minProperties': return `يجب ألا يحتوي على أقل من ${error.params.limit} خصائص`;
+        case 'minimum': return `يجب أن يكون ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `يجب أن يكون مضاعفًا لـ ${error.params.multipleOf}`;
+        case 'not': return 'يجب ألا يكون صالحًا';
+        case 'oneOf': return 'يجب أن يتطابق مع مخطط واحد بالضبط في واحد مما يلي';
+        case 'pattern': return `يجب أن يتطابق مع النمط "${error.params.pattern}"`;
+        case 'propertyNames': return `أسماء الخصائص ${error.params.propertyNames.join(', ')} غير صالحة`;
+        case 'required': return `يجب أن يحتوي على الخصائص المطلوبة ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `يجب أن يكون ${error.params.type}` : `يجب أن يكون إما ${error.params.type.join(' أو ')}`;
+        case 'unevaluatedItems': return 'يجب ألا يحتوي على عناصر غير مقيمة';
+        case 'unevaluatedProperties': return 'يجب ألا يحتوي على خصائص غير مقيمة';
+        case 'uniqueItems': return `يجب ألا يحتوي على عناصر مكررة`;
+        case '~guard': return `يجب أن يتطابق مع دالة الفحص`;
+        case '~refine': return error.params.message;
+        default: return 'حدث خطأ غير معروف في التحقق من الصحة';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/bn_BD.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Bengali (Bangladesh) - ISO 639-1 language code 'bn' with ISO 3166-1 alpha-2 country code 'BD' for Bangladesh. */
+export declare function bn_BD(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/bn_BD.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Bengali (Bangladesh) - ISO 639-1 language code 'bn' with ISO 3166-1 alpha-2 country code 'BD' for Bangladesh. */
+export function bn_BD(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'অতিরিক্ত বৈশিষ্ট্য থাকতে পারবে না';
+        case 'anyOf': return 'anyOf-এর একটি স্কিমার সাথে মিলতে হবে';
+        case 'boolean': return 'স্কিমা মিথ্যা';
+        case 'const': return 'ধ্রুবকের সমান হতে হবে';
+        case 'contains': return 'অন্তত 1টি বৈধ আইটেম থাকতে হবে';
+        case 'dependencies': return `যখন ${error.params.property} বৈশিষ্ট্য বিদ্যমান থাকে, তখন ${error.params.dependencies.join(', ')} বৈশিষ্ট্য থাকতে হবে`;
+        case 'dependentRequired': return `যখন ${error.params.property} বৈশিষ্ট্য বিদ্যমান থাকে, তখন ${error.params.dependencies.join(', ')} বৈশিষ্ট্য থাকতে হবে`;
+        case 'enum': return 'অনুমোদিত মানগুলির একটির সমান হতে হবে';
+        case 'exclusiveMaximum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'exclusiveMinimum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'format': return `অবশ্যই "${error.params.format}" ফরম্যাটের সাথে মিলতে হবে`;
+        case 'if': return `অবশ্যই "${error.params.failingKeyword}" স্কিমার সাথে মিলতে হবে`;
+        case 'maxItems': return `${error.params.limit}টির বেশি আইটেম থাকতে পারবে না`;
+        case 'maxLength': return `${error.params.limit}টির বেশি অক্ষর থাকতে পারবে না`;
+        case 'maxProperties': return `${error.params.limit}টির বেশি বৈশিষ্ট্য থাকতে পারবে না`;
+        case 'maximum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'minItems': return `${error.params.limit}টির কম আইটেম থাকতে পারবে না`;
+        case 'minLength': return `${error.params.limit}টির কম অক্ষর থাকতে পারবে না`;
+        case 'minProperties': return `${error.params.limit}টির কম বৈশিষ্ট্য থাকতে পারবে না`;
+        case 'minimum': return `অবশ্যই ${error.params.comparison} ${error.params.limit} হতে হবে`;
+        case 'multipleOf': return `${error.params.multipleOf}-এর গুণিতক হতে হবে`;
+        case 'not': return 'বৈধ হতে পারবে না';
+        case 'oneOf': return 'oneOf-এর শুধুমাত্র একটি স্কিমার সাথে মিলতে হবে';
+        case 'pattern': return `অবশ্যই "${error.params.pattern}" প্যাটার্নের সাথে মিলতে হবে`;
+        case 'propertyNames': return `বৈশিষ্ট্য নাম ${error.params.propertyNames.join(', ')} অবৈধ`;
+        case 'required': return `প্রয়োজনীয় বৈশিষ্ট্য ${error.params.requiredProperties.join(', ')} থাকতে হবে`;
+        case 'type': return typeof error.params.type === 'string' ? `অবশ্যই ${error.params.type} হতে হবে` : `অবশ্যই ${error.params.type.join(' অথবা ')} হতে হবে`;
+        case 'unevaluatedItems': return 'অবমূল্যায়িত আইটেম থাকতে পারবে না';
+        case 'unevaluatedProperties': return 'অবমূল্যায়িত বৈশিষ্ট্য থাকতে পারবে না';
+        case 'uniqueItems': return `অনুলিপি আইটেম থাকতে পারবে না`;
+        case '~guard': return `চেক ফাংশনের সাথে মেলাতে হবে`;
+        case '~refine': return error.params.message;
+        default: return 'একটি অজানা বৈধকরণ ত্রুটি ঘটেছে';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/cs_CZ.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Czech (Czech Republic) - ISO 639-1 language code 'cs' with ISO 3166-1 alpha-2 country code 'CZ' for Czech Republic. */
+export declare function cs_CZ(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/cs_CZ.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Czech (Czech Republic) - ISO 639-1 language code 'cs' with ISO 3166-1 alpha-2 country code 'CZ' for Czech Republic. */
+export function cs_CZ(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'nesmí mít další vlastnosti';
+        case 'anyOf': return 'musí odpovídat schématu v anyOf';
+        case 'boolean': return 'schéma je nepravdivé';
+        case 'const': return 'musí být rovno konstantě';
+        case 'contains': return 'musí obsahovat alespoň 1 platnou položku';
+        case 'dependencies': return `musí mít vlastnosti ${error.params.dependencies.join(', ')}, pokud je vlastnost ${error.params.property} přítomna`;
+        case 'dependentRequired': return `musí mít vlastnosti ${error.params.dependencies.join(', ')}, pokud je vlastnost ${error.params.property} přítomna`;
+        case 'enum': return 'musí být rovno jedné z povolených hodnot';
+        case 'exclusiveMaximum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `musí odpovídat formátu "${error.params.format}"`;
+        case 'if': return `musí odpovídat schématu "${error.params.failingKeyword}"`;
+        case 'maxItems': return `nesmí mít více než ${error.params.limit} položek`;
+        case 'maxLength': return `nesmí mít více než ${error.params.limit} znaků`;
+        case 'maxProperties': return `nesmí mít více než ${error.params.limit} vlastností`;
+        case 'maximum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `nesmí mít méně než ${error.params.limit} položek`;
+        case 'minLength': return `nesmí mít méně než ${error.params.limit} znaků`;
+        case 'minProperties': return `nesmí mít méně než ${error.params.limit} vlastností`;
+        case 'minimum': return `musí být ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `musí být násobkem ${error.params.multipleOf}`;
+        case 'not': return 'nesmí být platné';
+        case 'oneOf': return 'musí odpovídat přesně jednomu schématu v oneOf';
+        case 'pattern': return `musí odpovídat vzoru "${error.params.pattern}"`;
+        case 'propertyNames': return `názvy vlastností ${error.params.propertyNames.join(', ')} jsou neplatné`;
+        case 'required': return `musí mít povinné vlastnosti ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `musí být ${error.params.type}` : `musí být ${error.params.type.join(' nebo ')}`;
+        case 'unevaluatedItems': return 'nesmí mít nevyhodnocené položky';
+        case 'unevaluatedProperties': return 'nesmí mít nevyhodnocené vlastnosti';
+        case 'uniqueItems': return `nesmí mít duplicitní položky`;
+        case '~guard': return `musí odpovídat kontrolní funkci`;
+        case '~refine': return error.params.message;
+        default: return 'došlo k neznámé chybě ověření';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/de_DE.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/**  German (Germany) - ISO 639-1 language code 'de' with ISO 3166-1 alpha-2 country code 'DE' for Germany. */
+export declare function de_DE(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/de_DE.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/**  German (Germany) - ISO 639-1 language code 'de' with ISO 3166-1 alpha-2 country code 'DE' for Germany. */
+export function de_DE(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'darf keine zusätzlichen Eigenschaften haben';
+        case 'anyOf': return 'muss einem Schema in „anyOf“ entsprechen';
+        case 'boolean': return 'Schema ist falsch';
+        case 'const': return 'muss gleich der Konstante sein';
+        case 'contains': return 'muss mindestens 1 gültiges Element enthalten';
+        case 'dependencies': return `muss die Eigenschaften ${error.params.dependencies.join(', ')} haben, wenn Eigenschaft ${error.params.property} vorhanden ist`;
+        case 'dependentRequired': return `muss die Eigenschaften ${error.params.dependencies.join(', ')} haben, wenn Eigenschaft ${error.params.property} vorhanden ist`;
+        case 'enum': return 'muss einem der erlaubten Werte entsprechen';
+        case 'exclusiveMaximum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'exclusiveMinimum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'format': return `muss dem Format "${error.params.format}" entsprechen`;
+        case 'if': return `muss dem Schema "${error.params.failingKeyword}" entsprechen`;
+        case 'maxItems': return `darf nicht mehr als ${error.params.limit} Elemente haben`;
+        case 'maxLength': return `darf nicht mehr als ${error.params.limit} Zeichen haben`;
+        case 'maxProperties': return `darf nicht mehr als ${error.params.limit} Eigenschaften haben`;
+        case 'maximum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'minItems': return `darf nicht weniger als ${error.params.limit} Elemente haben`;
+        case 'minLength': return `darf nicht weniger als ${error.params.limit} Zeichen haben`;
+        case 'minProperties': return `darf nicht weniger als ${error.params.limit} Eigenschaften haben`;
+        case 'minimum': return `muss ${error.params.comparison} ${error.params.limit} sein`;
+        case 'multipleOf': return `muss ein Vielfaches von ${error.params.multipleOf} sein`;
+        case 'not': return 'darf nicht gültig sein';
+        case 'oneOf': return 'muss genau einem Schema in „oneOf“ entsprechen';
+        case 'pattern': return `muss dem Muster "${error.params.pattern}" entsprechen`;
+        case 'propertyNames': return `Eigenschaftsnamen ${error.params.propertyNames.join(', ')} sind ungültig`;
+        case 'required': return `muss die erforderlichen Eigenschaften ${error.params.requiredProperties.join(', ')} haben`;
+        case 'type': return typeof error.params.type === 'string' ? `muss ${error.params.type} sein` : `muss entweder ${error.params.type.join(' oder ')} sein`;
+        case 'unevaluatedItems': return 'darf keine unbewerteten Elemente haben';
+        case 'unevaluatedProperties': return 'darf keine unbewerteten Eigenschaften haben';
+        case 'uniqueItems': return `darf keine doppelten Elemente haben`;
+        case '~guard': return `muss der Prüffunktion entsprechen`;
+        case '~refine': return error.params.message;
+        default: return 'ein unbekannter Validierungsfehler ist aufgetreten';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/el_GR.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** Greek (Greece) - ISO 639-1 language code 'el' with ISO 3166-1 alpha-2 country code 'GR' for Greece. */
+export declare function el_GR(error: TValidationError): string;

package/node_modules/typebox/build/system/locale/el_GR.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+/** Greek (Greece) - ISO 639-1 language code 'el' with ISO 3166-1 alpha-2 country code 'GR' for Greece. */
+export function el_GR(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return 'δεν πρέπει να έχει επιπλέον ιδιότητες';
+        case 'anyOf': return 'πρέπει να ταιριάζει με ένα σχήμα στο anyOf';
+        case 'boolean': return 'το σχήμα είναι ψευδές';
+        case 'const': return 'πρέπει να είναι ίσο με τη σταθερά';
+        case 'contains': return 'πρέπει να περιέχει τουλάχιστον 1 έγκυρο στοιχείο';
+        case 'dependencies': return `πρέπει να έχει ιδιότητες ${error.params.dependencies.join(', ')} όταν υπάρχει η ιδιότητα ${error.params.property}`;
+        case 'dependentRequired': return `πρέπει να έχει ιδιότητες ${error.params.dependencies.join(', ')} όταν υπάρχει η ιδιότητα ${error.params.property}`;
+        case 'enum': return 'πρέπει να είναι ίσο με μία από τις επιτρεπόμενες τιμές';
+        case 'exclusiveMaximum': return `πρέπει να είναι ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `πρέπει να είναι ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `πρέπει να ταιριάζει με τη μορφή "${error.params.format}"`;
+        case 'if': return `πρέπει να ταιριάζει με το σχήμα "${error.params.failingKeyword}"`;
+        case 'maxItems': return `δεν πρέπει να έχει περισσότερα από ${error.params.limit} στοιχεία`;
+        case 'maxLength': return `δεν πρέπει να έχει περισσότερους από ${error.params.limit} χαρακτήρες`;
+        case 'maxProperties': return `δεν πρέπει να έχει περισσότερες από ${error.params.limit} ιδιότητες`;
+        case 'maximum': return `πρέπει να είναι ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `δεν πρέπει να έχει λιγότερα από ${error.params.limit} στοιχεία`;
+        case 'minLength': return `δεν πρέπει να έχει λιγότερους από ${error.params.limit} χαρακτήρες`;
+        case 'minProperties': return `δεν πρέπει να έχει λιγότερες από ${error.params.limit} ιδιότητες`;
+        case 'minimum': return `πρέπει να είναι ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `πρέπει να είναι πολλαπλάσιο του ${error.params.multipleOf}`;
+        case 'not': return 'δεν πρέπει να είναι έγκυρο';
+        case 'oneOf': return 'πρέπει να ταιριάζει με ένα μόνο σχήμα στο oneOf';
+        case 'pattern': return `πρέπει να ταιριάζει με το μοτίβο "${error.params.pattern}"`;
+        case 'propertyNames': return `τα ονόματα ιδιοτήτων ${error.params.propertyNames.join(', ')} είναι μη έγκυρα`;
+        case 'required': return `πρέπει να έχει τις απαιτούμενες ιδιότητες ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `πρέπει να είναι ${error.params.type}` : `πρέπει να είναι είτε ${error.params.type.join(' ή ')}`;
+        case 'unevaluatedItems': return 'δεν πρέπει να έχει μη αξιολογημένα στοιχεία';
+        case 'unevaluatedProperties': return 'δεν πρέπει να έχει μη αξιολογημένες ιδιότητες';
+        case 'uniqueItems': return `δεν πρέπει να έχει διπλά στοιχεία`;
+        case '~guard': return `πρέπει να αντιστοιχεί στη συνάρτηση ελέγχου`;
+        case '~refine': return error.params.message;
+        default: return 'προέκυψε ένα άγνωστο σφάλμα επικύρωσης';
+    }
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/system/locale/en_US.d.mts

@@ -0,0 +1,3 @@
+import { type TValidationError } from '../../error/index.mjs';
+/** en_US: English (United States) - ISO 639-1 language code 'en' with ISO 3166-1 alpha-2 country code 'US' for United States. */
+export declare function en_US(error: TValidationError): string;