ajv-i18n - npm Package Compare versions

Comparing version 3.6.0 to 4.0.0-beta.0

localize/ar/index.js

@@ -1,149 +0,149 @@
-'use strict';
+"use strict"
 module.exports = function localize_ar(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'لا يمكن العثور على المرجع ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أكثر من ' + (n) + ' عنصر';
-        break;
-      case 'additionalProperties':
-        out = 'يجب أن لا يحوي خصائص إضافية';
-        break;
-      case 'anyOf':
-        out = 'يجب أن يوافق أحد المخططات الموجودة في "anyOf"';
-        break;
-      case 'const':
-        out = 'يجب أن يكون ثابتاً';
-        break;
-      case 'contains':
-        out = 'يجب أن يحوي عنصرا صحيح';
-        break;
-      case 'custom':
-        out = 'يجب أن تمرر كلمة التحقق المفتاحية "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += ' يجب أن يحوي الخصائص ' + (e.params.deps) + ' عندما تكون الخاصية ' + (e.params.property) + ' موجودة';
-        break;
-      case 'enum':
-        out = 'قيمة هذا الحقل يجب أن تكون مساوية لأحد القيم المعرفة مسبقاً';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'false schema':
-        out = 'المخطط المنطقي غير صحيح';
-        break;
-      case 'format':
-        out = 'يجب أن يوافق الصيغة "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum يجب أن يكون منطقياً';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum يجب أن يكون منطقياً';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'if':
-        out = 'يجب أن توافق المخطط "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أكثر من ' + (n) + ' عنصر';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أكثر من ' + (n) + ' محرف';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أكثر من ' + (n) + ' خصائص';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' يجب أن يكون ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أقل من ' + (n) + ' عنصر';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أقل من ' + (n) + ' محرف';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += ' يجب أن لا يحوي أقل من ' + (n) + ' خصائص';
-        break;
-      case 'multipleOf':
-        out = ' يجب أن يحوي أكثر من ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'يجب أن يكون غير صحيح وفقاً للمخطط "not"';
-        break;
-      case 'oneOf':
-        out = 'يجب أن يوافق مخطط واحد فقط موجود في "oneOf"';
-        break;
-      case 'pattern':
-        out = 'يجب أن يوافق النمط "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'يجب أن يحوي خاصية توافق النمط "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'اسم الخاصية \'' + (e.params.propertyName) + '\' غير صالح';
-        break;
-      case 'required':
-        out = 'هذا الحقل إلزامي';
-        break;
-      case 'switch':
-        out = 'يجب أن تمرر كلمة التحقق المفتاحية "switch"، الحالة ' + (e.params.caseIndex) + '  خاطئة';
-        break;
-      case 'type':
-        out = 'قيمة هذا الحقل غير صالحة';
-        break;
-      case 'uniqueItems':
-        out = 'يجب أن لا يحوي عناصر مكررة (العنصر ## ' + (e.params.j) + ' و ' + (e.params.i) + ' متطابقة)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أكثر من " + n + " عنصر"
+        break
+      case "additionalProperties":
+        out = "يجب أن لا يحوي خصائص إضافية"
+        break
+      case "anyOf":
+        out = 'يجب أن يوافق أحد المخططات الموجودة في "anyOf"'
+        break
+      case "const":
+        out = "يجب أن يكون ثابتاً"
+        break
+      case "contains":
+        out = "يجب أن يحوي عنصرا صحيح"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out +=
+          " يجب أن يحوي الخصائص " +
+          e.params.deps +
+          " عندما تكون الخاصية " +
+          e.params.property +
+          " موجودة"
+        break
+      case "enum":
+        out = "قيمة هذا الحقل يجب أن تكون مساوية لأحد القيم المعرفة مسبقاً"
+        break
+      case "false schema":
+        out = "المخطط المنطقي غير صحيح"
+        break
+      case "format":
+        out = 'يجب أن يوافق الصيغة "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " يجب أن يكون " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " يجب أن يكون " + cond
+        break
+      case "if":
+        out = 'يجب أن توافق المخطط "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " يجب أن يكون " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أكثر من " + n + " عنصر"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أكثر من " + n + " محرف"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أكثر من " + n + " خصائص"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " يجب أن يكون " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أقل من " + n + " عنصر"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أقل من " + n + " محرف"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += " يجب أن لا يحوي أقل من " + n + " خصائص"
+        break
+      case "multipleOf":
+        out = " يجب أن يحوي أكثر من " + e.params.multipleOf
+        break
+      case "not":
+        out = 'يجب أن يكون غير صحيح وفقاً للمخطط "not"'
+        break
+      case "oneOf":
+        out = 'يجب أن يوافق مخطط واحد فقط موجود في "oneOf"'
+        break
+      case "pattern":
+        out = 'يجب أن يوافق النمط "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out = 'يجب أن يحوي خاصية توافق النمط "' + e.params.missingPattern + '"'
+        break
+      case "propertyNames":
+        out = "اسم الخاصية غير صالح"
+        break
+      case "required":
+        out = "هذا الحقل إلزامي"
+        break
+      case "type":
+        out = "قيمة هذا الحقل غير صالحة"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "يجب أن لا يحوي عناصر مكررة (العنصر ## " +
+          e.params.j +
+          " و " +
+          e.params.i +
+          " متطابقة)"
+        break
       default:
-        continue;
+        out = 'يجب أن تمرر كلمة التحقق المفتاحية "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/ca/index.js

@@ -1,174 +0,178 @@
-'use strict';
+"use strict"
 module.exports = function localize_ca(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'no es pot resoldre la referència ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no ha de tenir més de ' + (n) + ' element';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "no ha de tenir més de " + n + " element"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'additionalProperties':
-        out = 'no ha de tenir propietats addicionals';
-        break;
-      case 'anyOf':
-        out = 'ha de coincidir amb algun esquema definit a "anyOf"';
-        break;
-      case 'const':
-        out = 'ha de ser igual a la constant';
-        break;
-      case 'contains':
-        out = 'ha de contenir un ítem vàlid';
-        break;
-      case 'custom':
-        out = 'ha de passar la validació de la clau "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'ha de contenir la propietat';
+        break
+      case "additionalProperties":
+        out = "no ha de tenir propietats addicionals"
+        break
+      case "anyOf":
+        out = 'ha de coincidir amb algun esquema definit a "anyOf"'
+        break
+      case "const":
+        out = "ha de ser igual a la constant"
+        break
+      case "contains":
+        out = "ha de contenir un ítem vàlid"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "ha de contenir la propietat"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' ' + (e.params.deps) + ' quan la propietat ' + (e.params.property) + ' és present';
-        break;
-      case 'enum':
-        out = 'ha de ser igual a un dels valors predefinits';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'false schema':
-        out = 'l’esquema és fals';
-        break;
-      case 'format':
-        out = 'ha de coincidir amb el format "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum ha de ser booleà';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum ha de ser booleà';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'if':
-        out = 'ha de correspondre’s amb l’esquema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no ha de tenir més de ' + (n) + ' ítem';
+        out +=
+          " " +
+          e.params.deps +
+          " quan la propietat " +
+          e.params.property +
+          " és present"
+        break
+      case "enum":
+        out = "ha de ser igual a un dels valors predefinits"
+        break
+      case "false schema":
+        out = "l’esquema és fals"
+        break
+      case "format":
+        out = 'ha de coincidir amb el format "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ha de ser " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ha de ser " + cond
+        break
+      case "if":
+        out =
+          'ha de correspondre’s amb l’esquema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ha de ser " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "no ha de tenir més de " + n + " ítem"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'no pot contenir més de ' + (n) + ' caràcter';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "no pot contenir més de " + n + " caràcter"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'no pot contenir més de ' + (n) + ' propietat';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "no pot contenir més de " + n + " propietat"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ha de ser ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no ha de tenir menys de ' + (n) + ' ítem';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ha de ser " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "no ha de tenir menys de " + n + " ítem"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'no pot contenir menys de ' + (n) + ' caràcter';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "no pot contenir menys de " + n + " caràcter"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'no pot contenir menys de ' + (n) + ' propietat';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "no pot contenir menys de " + n + " propietat"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'multipleOf':
-        out = 'ha de ser múltiple de ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'no ha de ser vàlid d’acord amb l’esquema definit a "not"';
-        break;
-      case 'oneOf':
-        out = 'ha de coincidir només amb un esquema definit a "oneOf"';
-        break;
-      case 'pattern':
-        out = 'ha de coincidir amb el patró "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'la propietat ha de coincidir amb el patró "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'la propietat \'' + (e.params.propertyName) + '\' no és vàlida';
-        break;
-      case 'required':
-        out = 'ha de tenir la propietat requerida ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'ha de passar la validació "switch", el cas ' + (e.params.caseIndex) + ' falla';
-        break;
-      case 'type':
-        out = 'ha de ser del tipus ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'no ha de tenir ítems duplicats (els ítems ## ' + (e.params.j) + ' i ' + (e.params.i) + ' són idèntics)';
-        break;
+        break
+      case "multipleOf":
+        out = "ha de ser múltiple de " + e.params.multipleOf
+        break
+      case "not":
+        out = 'no ha de ser vàlid d’acord amb l’esquema definit a "not"'
+        break
+      case "oneOf":
+        out = 'ha de coincidir només amb un esquema definit a "oneOf"'
+        break
+      case "pattern":
+        out = 'ha de coincidir amb el patró "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'la propietat ha de coincidir amb el patró "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "la propietat no és vàlida"
+        break
+      case "required":
+        out = "ha de tenir la propietat requerida " + e.params.missingProperty
+        break
+      case "type":
+        out = "ha de ser del tipus " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "no ha de tenir ítems duplicats (els ítems ## " +
+          e.params.j +
+          " i " +
+          e.params.i +
+          " són idèntics)"
+        break
       default:
-        continue;
+        out = 'ha de passar la validació de la clau "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/de/index.js

@@ -1,173 +0,180 @@
-'use strict';
+"use strict"
 module.exports = function localize_de(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'kann die Referenz ' + (e.params.ref) + ' nicht auflösen';
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht mehr als ' + (n) + ' Element';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht mehr als " + n + " Element"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' enthalten';
-        break;
-      case 'additionalProperties':
-        out = 'darf keine zusätzlichen Attribute haben';
-        break;
-      case 'anyOf':
-        out = 'muss einem der Schemata in "anyOf" entsprechen';
-        break;
-      case 'const':
-        out = 'muss gleich der Konstanten sein';
-        break;
-      case 'contains':
-        out = 'muss ein valides Element enthalten';
-        break;
-      case 'custom':
-        out = 'muss die Validierung "' + (e.keyword) + '" bestehen';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'muss Attribut';
+        out += " enthalten"
+        break
+      case "additionalProperties":
+        out = "darf keine zusätzlichen Attribute haben"
+        break
+      case "anyOf":
+        out = 'muss einem der Schemata in "anyOf" entsprechen'
+        break
+      case "const":
+        out = "muss gleich der Konstanten sein"
+        break
+      case "contains":
+        out = "muss ein valides Element enthalten"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "muss Attribut"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' ' + (e.params.deps) + ' aufweisen, wenn Attribut ' + (e.params.property) + ' gesetzt ist';
-        break;
-      case 'enum':
-        out = 'muss einem der vorgegebenen Werte entsprechen';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'false schema':
-        out = 'boolesches Schema ist falsch';
-        break;
-      case 'format':
-        out = 'muss diesem Format entsprechen: "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum muss ein boolescher Wert sein';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum muss ein boolescher Wert sein';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'if':
-        out = 'muss dem Schema "' + (e.params.failingKeyword) + '" entsprechen';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht mehr als ' + (n) + ' Element';
+        out +=
+          " " +
+          e.params.deps +
+          " aufweisen, wenn Attribut " +
+          e.params.property +
+          " gesetzt ist"
+        break
+      case "enum":
+        out = "muss einem der vorgegebenen Werte entsprechen"
+        break
+      case "false schema":
+        out = "boolesches Schema ist falsch"
+        break
+      case "format":
+        out = 'muss diesem Format entsprechen: "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "muss " + cond + " sein"
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "muss " + cond + " sein"
+        break
+      case "if":
+        out = 'muss dem Schema "' + e.params.failingKeyword + '" entsprechen'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "muss " + cond + " sein"
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht mehr als " + n + " Element"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' haben';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht länger als ' + (n) + ' Zeichen sein';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht mehr als ' + (n) + ' Attribut';
+        out += " haben"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht länger als " + n + " Zeichen sein"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht mehr als " + n + " Attribut"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' haben';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'muss ' + (cond) + ' sein';
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht weniger als ' + (n) + ' Element';
+        out += " haben"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "muss " + cond + " sein"
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht weniger als " + n + " Element"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' haben';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht kürzer als ' + (n) + ' Zeichen sein';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'darf nicht weniger als ' + (n) + ' Attribut';
+        out += " haben"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht kürzer als " + n + " Zeichen sein"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "darf nicht weniger als " + n + " Attribut"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' haben';
-        break;
-      case 'multipleOf':
-        out = 'muss ein Vielfaches von ' + (e.params.multipleOf) + ' sein';
-        break;
-      case 'not':
-        out = 'muss dem in "not" angegebenen Schema widersprechen';
-        break;
-      case 'oneOf':
-        out = 'muss genau einem der Schemata in "oneOf" entsprechen';
-        break;
-      case 'pattern':
-        out = 'muss diesem Muster entsprechen: "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'muss ein Attribut nach folgendem Muster haben "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'Attributname \'' + (e.params.propertyName) + '\' ist ungültig';
-        break;
-      case 'required':
-        out = 'muss das erforderliche Attribut ' + (e.params.missingProperty) + ' enthalten';
-        break;
-      case 'switch':
-        out = 'muss der "switch"-Validierung entsprechen, der Fall ' + (e.params.caseIndex) + ' schlägt fehl';
-        break;
-      case 'type':
-        out = 'muss sein: ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'darf keine Duplikate enthalten (Elemente #' + (e.params.j) + ' und #' + (e.params.i) + ' sind gleich)';
-        break;
+        out += " haben"
+        break
+      case "multipleOf":
+        out = "muss ein Vielfaches von " + e.params.multipleOf + " sein"
+        break
+      case "not":
+        out = 'muss dem in "not" angegebenen Schema widersprechen'
+        break
+      case "oneOf":
+        out = 'muss genau einem der Schemata in "oneOf" entsprechen'
+        break
+      case "pattern":
+        out = 'muss diesem Muster entsprechen: "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'muss ein Attribut nach folgendem Muster haben "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "Attributname ist ungültig"
+        break
+      case "required":
+        out =
+          "muss das erforderliche Attribut " +
+          e.params.missingProperty +
+          " enthalten"
+        break
+      case "type":
+        out = "muss sein: " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "darf nicht mehr als " + n + " Element"
+        if (n != 1) {
+          out += "e"
+        }
+        out += " haben"
+        break
+      case "unevaluatedProperties":
+        out = "darf keine unausgewerteten Attribute haben"
+        break
+      case "uniqueItems":
+        out =
+          "darf keine Duplikate enthalten (Elemente #" +
+          e.params.j +
+          " und #" +
+          e.params.i +
+          " sind gleich)"
+        break
       default:
-        continue;
+        out = 'muss die Validierung "' + e.keyword + '" bestehen'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/en/index.js

@@ -1,180 +0,183 @@
-'use strict';
+"use strict"
 module.exports = function localize_en(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'can\\\'t resolve reference ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not have more than ' + (n) + ' item';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT have more than " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'additionalProperties':
-        out = 'should not have additional properties';
-        break;
-      case 'anyOf':
-        out = 'should match some schema in "anyOf"';
-        break;
-      case 'const':
-        out = 'should be equal to constant';
-        break;
-      case 'contains':
-        out = 'should contain a valid item';
-        break;
-      case 'custom':
-        out = 'should pass "' + (e.keyword) + '" keyword validation';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'should have propert';
+        break
+      case "additionalProperties":
+        out = "must NOT have additional properties"
+        break
+      case "anyOf":
+        out = 'must match a schema in "anyOf"'
+        break
+      case "const":
+        out = "must be equal to constant"
+        break
+      case "contains":
+        out = "must contain a valid item"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "must have propert"
         if (n == 1) {
-          out += 'y';
+          out += "y"
         } else {
-          out += 'ies';
+          out += "ies"
         }
-        out += ' ' + (e.params.deps) + ' when property ' + (e.params.property) + ' is present';
-        break;
-      case 'enum':
-        out = 'should be equal to one of predefined values';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'false schema':
-        out = 'boolean schema is false';
-        break;
-      case 'format':
-        out = 'should match format "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum should be boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum should be boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not have more than ' + (n) + ' item';
+        out +=
+          " " +
+          e.params.deps +
+          " when property " +
+          e.params.property +
+          " is present"
+        break
+      case "enum":
+        out = "must be equal to one of the allowed values"
+        break
+      case "false schema":
+        out = "boolean schema is false"
+        break
+      case "format":
+        out = 'must match format "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT have more than " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not be longer than ' + (n) + ' character';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT be longer than " + n + " character"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not have more than ' + (n) + ' propert';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT have more than " + n + " propert"
         if (n == 1) {
-          out += 'y';
+          out += "y"
         } else {
-          out += 'ies';
+          out += "ies"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not have less than ' + (n) + ' item';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT have less than " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not be shorter than ' + (n) + ' character';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT be shorter than " + n + " character"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'should not have less than ' + (n) + ' propert';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "must NOT have less than " + n + " propert"
         if (n == 1) {
-          out += 'y';
+          out += "y"
         } else {
-          out += 'ies';
+          out += "ies"
         }
-        break;
-      case 'multipleOf':
-        out = 'should be a multiple of ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'should not be valid according to schema in "not"';
-        break;
-      case 'oneOf':
-        out = 'should match exactly one schema in "oneOf"';
-        break;
-      case 'pattern':
-        out = 'should match pattern "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'should have property matching pattern "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'property name \'' + (e.params.propertyName) + '\' is invalid';
-        break;
-      case 'required':
-        out = 'should have required property ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'should pass "switch" keyword validation, case ' + (e.params.caseIndex) + ' fails';
-        break;
-      case 'type':
-        out = 'should be ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'should not have duplicate items (items ## ' + (e.params.j) + ' and ' + (e.params.i) + ' are identical)';
-        break;
+        break
+      case "multipleOf":
+        out = "must be a multiple of " + e.params.multipleOf
+        break
+      case "not":
+        out = 'must NOT be valid according to schema in "not"'
+        break
+      case "oneOf":
+        out = 'must match exactly one schema in "oneOf"'
+        break
+      case "pattern":
+        out = 'must match pattern "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'must have property matching pattern "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "property name is invalid"
+        break
+      case "required":
+        out = "must have required property " + e.params.missingProperty
+        break
+      case "type":
+        out = "must be " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "must NOT have duplicate items (items ## " +
+          e.params.j +
+          " and " +
+          e.params.i +
+          " are identical)"
+        break
       default:
-        continue;
+        out = 'must pass "' + e.keyword + '" keyword validation'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/es/index.js

@@ -1,178 +0,182 @@
-'use strict';
+"use strict"
 module.exports = function localize_es(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'no se puede resolver la referencia ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe tener más de ' + (n) + ' elemento';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "no debe tener más de " + n + " elemento"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'additionalProperties':
-        out = 'no debe tener propiedades adicionales';
-        break;
-      case 'anyOf':
-        out = 'debe coincidir con algún esquema en "anyOf"';
-        break;
-      case 'const':
-        out = 'debe ser igual a la constante';
-        break;
-      case 'contains':
-        out = 'debe contener un elemento válido';
-        break;
-      case 'custom':
-        out = 'debe pasar la validación de palabra clave "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'debe contener la';
+        break
+      case "additionalProperties":
+        out = "no debe tener propiedades adicionales"
+        break
+      case "anyOf":
+        out = 'debe coincidir con algún esquema en "anyOf"'
+        break
+      case "const":
+        out = "debe ser igual a la constante"
+        break
+      case "contains":
+        out = "debe contener un elemento válido"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "debe contener la"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' propiedad';
+        out += " propiedad"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        out += ' ' + (e.params.deps) + ' cuando la propiedad ' + (e.params.property) + ' se encuentra presente';
-        break;
-      case 'enum':
-        out = 'deber ser igual a uno de los valores predefinidos';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'false schema':
-        out = 'el esquema és falso';
-        break;
-      case 'format':
-        out = 'debe coincidir con el formato "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum debe ser booleano';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum debe ser booleano';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'if':
-        out = 'debe corresponderse con el esquema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener más de ' + (n) + ' elemento';
+        out +=
+          " " +
+          e.params.deps +
+          " cuando la propiedad " +
+          e.params.property +
+          " se encuentra presente"
+        break
+      case "enum":
+        out = "deber ser igual a uno de los valores predefinidos"
+        break
+      case "false schema":
+        out = "el esquema és falso"
+        break
+      case "format":
+        out = 'debe coincidir con el formato "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "debe ser " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "debe ser " + cond
+        break
+      case "if":
+        out =
+          'debe corresponderse con el esquema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "debe ser " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener más de " + n + " elemento"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener más de ' + (n) + ' caracter';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener más de " + n + " caracter"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener más de ' + (n) + ' propiedad';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener más de " + n + " propiedad"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'debe ser ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener menos de ' + (n) + ' elemento';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "debe ser " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener menos de " + n + " elemento"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener menos de ' + (n) + ' caracter';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener menos de " + n + " caracter"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'no debe contener menos de ' + (n) + ' propiedad';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "no debe contener menos de " + n + " propiedad"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'multipleOf':
-        out = 'debe ser múltiplo de ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'no debe ser válido según el esquema en "not"';
-        break;
-      case 'oneOf':
-        out = 'debe coincidir con un solo esquema en "oneOf"';
-        break;
-      case 'pattern':
-        out = 'debe coincidir con el patron "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'la propiedad debe coincidir con el patrón "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'la propiedad \'' + (e.params.propertyName) + '\' no és válida';
-        break;
-      case 'required':
-        out = 'debe tener la propiedad requerida ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'debe pasar la validación "switch" de palabra clave, el caso ' + (e.params.caseIndex) + ' falló';
-        break;
-      case 'type':
-        out = 'debe ser ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'no debe contener elementos duplicados, (los elementos ## ' + (e.params.j) + ' y ' + (e.params.i) + ' son idénticos)';
-        break;
+        break
+      case "multipleOf":
+        out = "debe ser múltiplo de " + e.params.multipleOf
+        break
+      case "not":
+        out = 'no debe ser válido según el esquema en "not"'
+        break
+      case "oneOf":
+        out = 'debe coincidir con un solo esquema en "oneOf"'
+        break
+      case "pattern":
+        out = 'debe coincidir con el patron "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'la propiedad debe coincidir con el patrón "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "la propiedad no és válida"
+        break
+      case "required":
+        out = "debe tener la propiedad requerida " + e.params.missingProperty
+        break
+      case "type":
+        out = "debe ser " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "no debe contener elementos duplicados, (los elementos ## " +
+          e.params.j +
+          " y " +
+          e.params.i +
+          " son idénticos)"
+        break
       default:
-        continue;
+        out = 'debe pasar la validación de palabra clave "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/fr/index.js

@@ -1,170 +0,173 @@
-'use strict';
+"use strict"
 module.exports = function localize_fr(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'impossible d\\\'accéder à la référénce ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas contenir plus de ' + (n) + ' élémént';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas contenir plus de " + n + " élémént"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'additionalProperties':
-        out = 'ne doit pas contenir de propriétés additionnelles';
-        break;
-      case 'anyOf':
-        out = 'doit correspondre à un schéma de "anyOf"';
-        break;
-      case 'const':
-        out = 'doit être égal à la constante';
-        break;
-      case 'contains':
-        out = 'doit contenir un élément valide';
-        break;
-      case 'custom':
-        out = 'doit être valide selon le critère "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'doit avoir la propriété ' + (e.params.deps) + ' quand la propriété ' + (e.params.property) + ' est présente';
-        break;
-      case 'enum':
-        out = 'doit être égal à une des valeurs prédéfinies';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'false schema':
-        out = 'le schema est "false"';
-        break;
-      case 'format':
-        out = 'doit correspondre au format "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum doit être un booléen';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum doit être un booléen';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'if':
-        out = 'doit correspondre au schéma "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas contenir plus de ' + (n) + ' élément';
+        break
+      case "additionalProperties":
+        out = "ne doit pas contenir de propriétés additionnelles"
+        break
+      case "anyOf":
+        out = 'doit correspondre à un schéma de "anyOf"'
+        break
+      case "const":
+        out = "doit être égal à la constante"
+        break
+      case "contains":
+        out = "doit contenir un élément valide"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out +=
+          "doit avoir la propriété " +
+          e.params.deps +
+          " quand la propriété " +
+          e.params.property +
+          " est présente"
+        break
+      case "enum":
+        out = "doit être égal à une des valeurs prédéfinies"
+        break
+      case "false schema":
+        out = 'le schema est "false"'
+        break
+      case "format":
+        out = 'doit correspondre au format "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "doit être " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "doit être " + cond
+        break
+      case "if":
+        out = 'doit correspondre au schéma "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "doit être " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas contenir plus de " + n + " élément"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas dépasser ' + (n) + ' caractère';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas dépasser " + n + " caractère"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas contenir plus de ' + (n) + ' propriété';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas contenir plus de " + n + " propriété"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'doit être ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas contenir moins de ' + (n) + ' élément';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "doit être " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas contenir moins de " + n + " élément"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas faire moins de ' + (n) + ' caractère';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas faire moins de " + n + " caractère"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'ne doit pas contenir moins de ' + (n) + ' propriété';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "ne doit pas contenir moins de " + n + " propriété"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'multipleOf':
-        out = 'doit être un multiple de ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'est invalide selon le schéma "not"';
-        break;
-      case 'oneOf':
-        out = 'doit correspondre à exactement un schéma de "oneOf"';
-        break;
-      case 'pattern':
-        out = 'doit correspondre au format "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'la propriété doit correspondre au format "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'le nom de propriété \'' + (e.params.propertyName) + '\' est invalide';
-        break;
-      case 'required':
-        out = 'requiert la propriété ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'doit être valide selon le critère "switch":validation par mot-clé, le cas ' + (e.params.caseIndex) + ' est invalide';
-        break;
-      case 'type':
-        out = 'doit être de type ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'ne doit pas contenir de doublons (les éléments ## ' + (e.params.j) + ' et ' + (e.params.i) + ' sont identiques)';
-        break;
+        break
+      case "multipleOf":
+        out = "doit être un multiple de " + e.params.multipleOf
+        break
+      case "not":
+        out = 'est invalide selon le schéma "not"'
+        break
+      case "oneOf":
+        out = 'doit correspondre à exactement un schéma de "oneOf"'
+        break
+      case "pattern":
+        out = 'doit correspondre au format "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'la propriété doit correspondre au format "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "le nom de propriété est invalide"
+        break
+      case "required":
+        out = "requiert la propriété " + e.params.missingProperty
+        break
+      case "type":
+        out = "doit être de type " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "ne doit pas contenir de doublons (les éléments ## " +
+          e.params.j +
+          " et " +
+          e.params.i +
+          " sont identiques)"
+        break
       default:
-        continue;
+        out = 'doit être valide selon le critère "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/hu/index.js

@@ -1,157 +0,164 @@
-'use strict';
+"use strict"
 module.exports = function localize_hu(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'nem sikerült feloldani a hivatkozást ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet több, mint ' + (n) + ' eleme';
-        break;
-      case 'additionalProperties':
-        out = 'nem lehetnek további elemei';
-        break;
-      case 'anyOf':
-        out = 'meg kell feleljen legalább egy "anyOf" alaknak';
-        break;
-      case 'const':
-        out = 'should be equal to constant';
-        break;
-      case 'contains':
-        out = 'should contain a valid item';
-        break;
-      case 'custom':
-        out = 'should pass "' + (e.keyword) + '" keyword validation';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += '-nak kell legyen';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet több, mint " + n + " eleme"
+        break
+      case "additionalProperties":
+        out = "nem lehetnek további elemei"
+        break
+      case "anyOf":
+        out = 'meg kell feleljen legalább egy "anyOf" alaknak'
+        break
+      case "const":
+        out = "must be equal to constant"
+        break
+      case "contains":
+        out = "must contain a valid item"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "-nak kell legyen"
         if (n > 1) {
-          out += 'ek';
+          out += "ek"
         }
-        out += ' a következő tulajdonsága';
+        out += " a következő tulajdonsága"
         if (n != 1) {
-          out += 'i';
+          out += "i"
         }
-        out += ': ' + (e.params.deps) + ', ha van ' + (e.params.property) + ' tulajdonsága';
-        break;
-      case 'enum':
-        out = 'egyenlő kell legyen valamely előre meghatározott értékkel';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'kell legyen ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'kell legyen ' + (cond);
-        break;
-      case 'false schema':
-        out = 'boolean schema is false';
-        break;
-      case 'format':
-        out = 'meg kell feleljen a következő formátumnak: "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum should be boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum should be boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'kell legyen ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet több, mint ' + (n) + ' eleme';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet hosszabb, mint ' + (n) + ' szimbólum';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet több, mint ' + (n) + ' tulajdonsága';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'kell legyen ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet kevesebb, mint ' + (n) + ' eleme';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet rövidebb, mint ' + (n) + ' szimbólum';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nem lehet kevesebb, mint ' + (n) + ' tulajdonsága';
-        break;
-      case 'multipleOf':
-        out = 'a többszöröse kell legyen a következő számnak: ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'nem lehet érvényes a "not" alaknak megfelelően';
-        break;
-      case 'oneOf':
-        out = 'meg kell feleljen pontosan egy "anyOf" alaknak';
-        break;
-      case 'pattern':
-        out = 'meg kell feleljen a következő mintának: "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'should have property matching pattern "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'property name \'' + (e.params.propertyName) + '\' is invalid';
-        break;
-      case 'required':
-        out = 'kell legyen ' + (e.params.missingProperty) + ' tulajdonsága';
-        break;
-      case 'switch':
-        out = 'should pass "switch" keyword validation, case ' + (e.params.caseIndex) + ' fails';
-        break;
-      case 'type':
-        out = '' + (e.params.type) + ' kell legyen';
-        break;
-      case 'uniqueItems':
-        out = 'nem lehetnek azonos elemei (' + (e.params.j) + ' és ' + (e.params.i) + ' elemek azonosak)';
-        break;
+        out +=
+          ": " +
+          e.params.deps +
+          ", ha van " +
+          e.params.property +
+          " tulajdonsága"
+        break
+      case "enum":
+        out = "egyenlő kell legyen valamely előre meghatározott értékkel"
+        break
+      case "false schema":
+        out = "boolean schema is false"
+        break
+      case "format":
+        out =
+          'meg kell feleljen a következő formátumnak: "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "kell legyen " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet több, mint " + n + " eleme"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet hosszabb, mint " + n + " szimbólum"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet több, mint " + n + " tulajdonsága"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "kell legyen " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet kevesebb, mint " + n + " eleme"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet rövidebb, mint " + n + " szimbólum"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nem lehet kevesebb, mint " + n + " tulajdonsága"
+        break
+      case "multipleOf":
+        out =
+          "a többszöröse kell legyen a következő számnak: " +
+          e.params.multipleOf
+        break
+      case "not":
+        out = 'nem lehet érvényes a "not" alaknak megfelelően'
+        break
+      case "oneOf":
+        out = 'meg kell feleljen pontosan egy "oneOf" alaknak'
+        break
+      case "pattern":
+        out =
+          'meg kell feleljen a következő mintának: "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'must have property matching pattern "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "property name is invalid"
+        break
+      case "required":
+        out = "kell legyen " + e.params.missingProperty + " tulajdonsága"
+        break
+      case "type":
+        out = "" + e.params.type + " kell legyen"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "nem lehetnek azonos elemei (" +
+          e.params.j +
+          " és " +
+          e.params.i +
+          " elemek azonosak)"
+        break
       default:
-        continue;
+        out = 'must pass "' + e.keyword + '" keyword validation'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/id/index.js

@@ -1,149 +0,152 @@
-'use strict';
+"use strict"
 module.exports = function localize_id(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'tidak bisa menyelesaikan referensi ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh memiliki lebih dari ' + (n) + ' item';
-        break;
-      case 'additionalProperties':
-        out = 'tidak boleh memiliki properti tambahan';
-        break;
-      case 'anyOf':
-        out = 'harus cocok dengan beberapa skema pada "anyOf"';
-        break;
-      case 'const':
-        out = 'harus sama dengan konstan';
-        break;
-      case 'contains':
-        out = 'harus berisi item yang valid';
-        break;
-      case 'custom':
-        out = 'harus lulus validasi kata kunci "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += ' harus memiliki properti ' + (e.params.deps) + ' ketika properti ' + (e.params.property) + ' hadir';
-        break;
-      case 'enum':
-        out = 'harus sama dengan salah satu dari nilai yang telah ditentukan';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'false schema':
-        out = 'skema boolean salah';
-        break;
-      case 'format':
-        out = 'harus cocok dengan format "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum harus boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum harus boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'if':
-        out = 'harus cocok dengan skema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh memiliki lebih dari ' + (n) + ' item';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh lebih dari ' + (n) + ' karakter';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh memiliki lebih dari ' + (n) + ' properti';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'harus ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh kurang dari ' + (n) + ' item';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh lebih pendek dari ' + (n) + ' karakter';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += ' tidak boleh kurang dari ' + (n) + ' properti';
-        break;
-      case 'multipleOf':
-        out = 'harus merupakan kelipatan dari ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'tidak boleh valid sesuai dengan skema pada "not"';
-        break;
-      case 'oneOf':
-        out = 'harus sama persis dengan satu skema pada "oneOf"';
-        break;
-      case 'pattern':
-        out = 'harus cocok dengan pola "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'harus memiliki pola pencocokan properti "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'nama properti \'' + (e.params.propertyName) + '\' tidak valid';
-        break;
-      case 'required':
-        out = 'harus memiliki properti ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'harus lulus validasi kata kunci "switch", gagal pada ' + (e.params.caseIndex);
-        break;
-      case 'type':
-        out = 'harus berupa ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'tidak boleh memiliki item duplikat (item ## ' + (e.params.j) + ' dan ' + (e.params.i) + ' identik)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh memiliki lebih dari " + n + " item"
+        break
+      case "additionalProperties":
+        out = "tidak boleh memiliki properti tambahan"
+        break
+      case "anyOf":
+        out = 'harus cocok dengan beberapa skema pada "anyOf"'
+        break
+      case "const":
+        out = "harus sama dengan konstan"
+        break
+      case "contains":
+        out = "harus berisi item yang valid"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out +=
+          " harus memiliki properti " +
+          e.params.deps +
+          " ketika properti " +
+          e.params.property +
+          " hadir"
+        break
+      case "enum":
+        out = "harus sama dengan salah satu dari nilai yang telah ditentukan"
+        break
+      case "false schema":
+        out = "skema boolean salah"
+        break
+      case "format":
+        out = 'harus cocok dengan format "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "harus " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "harus " + cond
+        break
+      case "if":
+        out = 'harus cocok dengan skema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "harus " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh memiliki lebih dari " + n + " item"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh lebih dari " + n + " karakter"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh memiliki lebih dari " + n + " properti"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "harus " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh kurang dari " + n + " item"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh lebih pendek dari " + n + " karakter"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += " tidak boleh kurang dari " + n + " properti"
+        break
+      case "multipleOf":
+        out = "harus merupakan kelipatan dari " + e.params.multipleOf
+        break
+      case "not":
+        out = 'tidak boleh valid sesuai dengan skema pada "not"'
+        break
+      case "oneOf":
+        out = 'harus sama persis dengan satu skema pada "oneOf"'
+        break
+      case "pattern":
+        out = 'harus cocok dengan pola "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'harus memiliki pola pencocokan properti "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "nama properti tidak valid"
+        break
+      case "required":
+        out = "harus memiliki properti " + e.params.missingProperty
+        break
+      case "type":
+        out = "harus berupa " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "tidak boleh memiliki item duplikat (item ## " +
+          e.params.j +
+          " dan " +
+          e.params.i +
+          " identik)"
+        break
       default:
-        continue;
+        out = 'harus lulus validasi kata kunci "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/index.js

@@ -1,25 +0,25 @@
-'use strict';
-
+"use strict"
 module.exports = {
-    en: require('./en'),
-    ar: require('./ar'),
-    ca: require('./ca'),      
-    cz: require('./cz'),
-    de: require('./de'),
-    es: require('./es'),
-    fr: require('./fr'),
-    hu: require('./hu'),
-    it: require('./it'),
-    ja: require('./ja'),
-    ko: require('./ko'),
-    nb: require('./nb'),
-    nl: require('./nl'),
-    pl: require('./pl'),
-    'pt-BR': require('./pt-BR'),
-    ru: require('./ru'),
-    sk: require('./sk'),
-    sv: require('./sv'),
-    th: require('./th'),
-    zh: require('./zh'),
-    'zh-TW': require('./zh-TW'),
-};
+  en: require("./en"),
+  ar: require("./ar"),
+  ca: require("./ca"),
+  cs: require("./cs"),
+  de: require("./de"),
+  es: require("./es"),
+  fr: require("./fr"),
+  hu: require("./hu"),
+  id: require("./id"),
+  it: require("./it"),
+  ja: require("./ja"),
+  ko: require("./ko"),
+  nb: require("./nb"),
+  nl: require("./nl"),
+  pl: require("./pl"),
+  "pt-BR": require("./pt-BR"),
+  ru: require("./ru"),
+  sk: require("./sk"),
+  sv: require("./sv"),
+  th: require("./th"),
+  zh: require("./zh"),
+  "zh-TW": require("./zh-TW"),
+}

localize/it/index.js

@@ -1,196 +0,201 @@
-'use strict';
+"use strict"
 module.exports = function localize_it(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'non è possibile risolvere il riferimento ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'non dovrebbe avere più di ' + (n) + ' element';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "non dovrebbe avere più di " + n + " element"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'additionalProperties':
-        out = 'non deve avere attributi aggiuntivi';
-        break;
-      case 'anyOf':
-        out = 'deve corrispondere ad uno schema in "anyOf"';
-        break;
-      case 'const':
-        out = 'deve essere uguale alla costante';
-        break;
-      case 'contains':
-        out = 'deve contentere un elemento valido';
-        break;
-      case 'custom':
-        out = 'deve essere valido secondo il criterio "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'dovrebbe avere ';
+        break
+      case "additionalProperties":
+        out = "non deve avere attributi aggiuntivi"
+        break
+      case "anyOf":
+        out = 'deve corrispondere ad uno degli schema in "anyOf"'
+        break
+      case "const":
+        out = "deve essere uguale alla costante"
+        break
+      case "contains":
+        out = "deve contentere un elemento valido"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "dovrebbe avere "
         if (n == 1) {
-          out += 'l\'';
+          out += "l'"
         } else {
-          out += 'gli ';
+          out += "gli "
         }
-        out += 'attribut';
+        out += "attribut"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        out += ' ' + (e.params.deps) + ' quando l\'attributo ' + (e.params.property) + ' è presente';
-        break;
-      case 'enum':
-        out = 'dovrebbe essere uguale ad uno dei valori predefiniti';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'false schema':
-        out = 'lo schema booleano è falso';
-        break;
-      case 'format':
-        out = 'deve corrispondere al formato "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum deve essere booleano';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum deve essere booleano';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'if':
-        out = 'deve corrispondere allo schema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve avere più di ' + (n) + ' element';
+        out +=
+          " " +
+          e.params.deps +
+          " quando l'attributo " +
+          e.params.property +
+          " è presente"
+        break
+      case "enum":
+        out = "deve essere uguale ad uno dei valori consentiti"
+        break
+      case "false schema":
+        out = "lo schema booleano è falso"
+        break
+      case "format":
+        out = 'deve corrispondere al formato "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve essere " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve essere " + cond
+        break
+      case "if":
+        out = 'deve corrispondere allo schema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve essere " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "non deve avere più di " + n + " element"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve essere più lungo di ' + (n) + ' caratter';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "non deve essere più lungo di " + n + " caratter"
         if (n == 1) {
-          out += 'e';
+          out += "e"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve avere più di ' + (n) + ' attribut';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "non deve avere più di " + n + " attribut"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve essere ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve avere meno di ' + (n) + ' element';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve essere " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "non deve avere meno di " + n + " element"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve essere meno lungo di ' + (n) + ' caratter';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "non deve essere meno lungo di " + n + " caratter"
         if (n == 1) {
-          out += 'e';
+          out += "e"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'non deve avere meno di ' + (n) + ' attribut';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "non deve avere meno di " + n + " attribut"
         if (n == 1) {
-          out += 'o';
+          out += "o"
         } else {
-          out += 'i';
+          out += "i"
         }
-        break;
-      case 'multipleOf':
-        out = 'deve essere un multiplo di ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'non deve essere valido in base allo schema di "non"';
-        break;
-      case 'oneOf':
-        out = 'deve corrispondere esattamente ad uno schema in "oneOf"';
-        break;
-      case 'pattern':
-        out = 'deve corrispondere al formato "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'deve avere un attributo che corrisponda al formato "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'il nome dell\'attritbuto \'' + (e.params.propertyName) + '\' non è valido';
-        break;
-      case 'required':
-        out = 'deve avere l\'attributo obbligatorio ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'deve passare la validazione del criterio "switch", il caso ' + (e.params.caseIndex) + ' fallisce';
-        break;
-      case 'type':
-        out = 'deve essere di tipo ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'non deve avere duplicati (gli elementi ## ' + (e.params.j) + ' e ' + (e.params.i) + ' sono uguali)';
-        break;
+        break
+      case "multipleOf":
+        out = "deve essere un multiplo di " + e.params.multipleOf
+        break
+      case "not":
+        out = 'non deve essere valido in base allo schema di "non"'
+        break
+      case "oneOf":
+        out = 'deve corrispondere esattamente ad uno degli schema in "oneOf"'
+        break
+      case "pattern":
+        out = 'deve corrispondere al formato "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'deve avere un attributo che corrisponda al formato "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "il nome dell'attritbuto non è valido"
+        break
+      case "required":
+        out = "deve avere l'attributo obbligatorio " + e.params.missingProperty
+        break
+      case "type":
+        out = "deve essere di tipo " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "non deve avere più di " + n + " elementi"
+        if (n == 1) {
+          out += "o"
+        } else {
+          out += "i"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "non deve avere attributi non valutati"
+        break
+      case "uniqueItems":
+        out =
+          "non deve avere duplicati (gli elementi ## " +
+          e.params.j +
+          " e " +
+          e.params.i +
+          " sono uguali)"
+        break
       default:
-        continue;
+        out = 'deve essere valido secondo il criterio "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/ja/index.js

@@ -1,149 +0,148 @@
-'use strict';
+"use strict"
 module.exports = function localize_ja(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = '' + (e.params.ref) + 'のスキーマを見つけることができない';
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '以上あってはいけない';
-        break;
-      case 'additionalProperties':
-        out = '追加してはいけない';
-        break;
-      case 'anyOf':
-        out = '"anyOf"のスキーマとマッチしなくてはいけない';
-        break;
-      case 'const':
-        out = 'should be equal to constant';
-        break;
-      case 'contains':
-        out = 'should contain a valid item';
-        break;
-      case 'custom':
-        out = 'should pass "' + (e.keyword) + '" keyword validation';
-        break;
-      case 'dependencies':
-        out = '' + (e.params.property) + 'がある場合、';
-        var n = e.params.depsCount;
-        out += 'は' + (e.params.deps) + 'をつけなければいけない';
-        break;
-      case 'enum':
-        out = '事前に定義された値のいずれかに等しくなければいけない';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += (cond) + 'でなければいけない';
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += (cond) + 'でなければいけない';
-        break;
-      case 'false schema':
-        out = 'boolean schema is false';
-        break;
-      case 'format':
-        out = '"' + (e.params.format) + '"形式に揃えなければいけない';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum should be boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum should be boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'should be ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += (cond) + 'でなければいけない';
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '個以上であってはいけない';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '文字以上であってはいけない';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '個以上のプロパティを有してはいけない';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += (cond) + 'でなければいけない';
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '個以下であってはいけない';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '文字以下であってはいけない';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'は' + (n) + '個以下のプロパティを有してはいけない';
-        break;
-      case 'multipleOf':
-        out = '' + (e.params.multipleOf) + 'の倍数でなければいけない';
-        break;
-      case 'not':
-        out = '"not"のスキーマに従って有効としてはいけない';
-        break;
-      case 'oneOf':
-        out = '"oneOf"のスキーマと完全に一致しなくてはいけない';
-        break;
-      case 'pattern':
-        out = '"' + (e.params.pattern) + '"のパターンと一致しなければいけない';
-        break;
-      case 'patternRequired':
-        out = 'should have property matching pattern "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'property name \'' + (e.params.propertyName) + '\' is invalid';
-        break;
-      case 'required':
-        out = '必要なプロパティ' + (e.params.missingProperty) + 'がなければいけない';
-        break;
-      case 'switch':
-        out = 'should pass "switch" keyword validation, case ' + (e.params.caseIndex) + ' fails';
-        break;
-      case 'type':
-        out = '' + (e.params.type) + 'でなければいけない';
-        break;
-      case 'uniqueItems':
-        out = '重複するアイテムがあってはいけない（' + (e.params.j) + 'と' + (e.params.i) + 'は同じである）';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "以上あってはいけない"
+        break
+      case "additionalProperties":
+        out = "追加してはいけない"
+        break
+      case "anyOf":
+        out = '"anyOf"のスキーマとマッチしなくてはいけない'
+        break
+      case "const":
+        out = "must be equal to constant"
+        break
+      case "contains":
+        out = "must contain a valid item"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = "" + e.params.property + "がある場合、"
+        var n = e.params.depsCount
+        out += "は" + e.params.deps + "をつけなければいけない"
+        break
+      case "enum":
+        out = "事前に定義された値のいずれかに等しくなければいけない"
+        break
+      case "false schema":
+        out = "boolean schema is false"
+        break
+      case "format":
+        out = '"' + e.params.format + '"形式に揃えなければいけない'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "must be " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += cond + "でなければいけない"
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "個以上であってはいけない"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "文字以上であってはいけない"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "個以上のプロパティを有してはいけない"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += cond + "でなければいけない"
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "個以下であってはいけない"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "文字以下であってはいけない"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "は" + n + "個以下のプロパティを有してはいけない"
+        break
+      case "multipleOf":
+        out = "" + e.params.multipleOf + "の倍数でなければいけない"
+        break
+      case "not":
+        out = '"not"のスキーマに従って有効としてはいけない'
+        break
+      case "oneOf":
+        out = '"oneOf"のスキーマと完全に一致しなくてはいけない'
+        break
+      case "pattern":
+        out = '"' + e.params.pattern + '"のパターンと一致しなければいけない'
+        break
+      case "patternRequired":
+        out =
+          'must have property matching pattern "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "property name is invalid"
+        break
+      case "required":
+        out =
+          "必要なプロパティ" + e.params.missingProperty + "がなければいけない"
+        break
+      case "type":
+        out = "" + e.params.type + "でなければいけない"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "重複するアイテムがあってはいけない（" +
+          e.params.j +
+          "と" +
+          e.params.i +
+          "は同じである）"
+        break
       default:
-        continue;
+        out = 'must pass "' + e.keyword + '" keyword validation'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/ko/index.js

@@ -1,149 +0,151 @@
-'use strict';
+"use strict"
 module.exports = function localize_ko(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = '' + (e.params.ref) + ' 참조를 찾을 수 없습니다';
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += ' 항목은 아이템을 ' + (n) + '개 이상 가질 수 없습니다';
-        break;
-      case 'additionalProperties':
-        out = '추가적인 속성은 허용되지 않습니다';
-        break;
-      case 'anyOf':
-        out = '"anyOf"의 스키마와 일치해야 합니다';
-        break;
-      case 'const':
-        out = '상수와 같아야합니다';
-        break;
-      case 'contains':
-        out = '올바른 아이템을 포함해야 합니다';
-        break;
-      case 'custom':
-        out = '"' + (e.keyword) + '"키워드 검사를 통과해야 합니다';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += (e.params.property) + '속성이 있는 경우, ' + (e.params.deps) + ' 속성이 있어야합니다';
-        break;
-      case 'enum':
-        out = '미리 정의된 값중 하나여야 합니다';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'false schema':
-        out = 'boolean 스키마는 올바르지 않습니다';
-        break;
-      case 'format':
-        out = '"' + (e.params.format) + '" 포맷과 일치해야 합니다';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum 은 boolean 값이여야 합니다';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum 은 boolean 값이여야 합니다';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'if':
-        out = '"' + (e.params.failingKeyword) + '" 스키마와 일치해야 합니다';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += '아이템이 최대 ' + (n) + '개이여야 합니다';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += '최대 ' + (n) + '글자여야 합니다';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '속성은 최대 ' + (n) + '개 이내여야 합니다';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += ' ' + (cond) + ' 이여야 합니다';
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += '아이템이 최소 ' + (n) + '개이여야 합니다';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += '최소 ' + (n) + '글자여야 합니다';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '속성은 최소 ' + (n) + '개 이상이여야 합니다';
-        break;
-      case 'multipleOf':
-        out = '' + (e.params.multipleOf) + '의 배수여야 합니다';
-        break;
-      case 'not':
-        out = '"not"스키마에 따라 유효하지 않아야 합니다';
-        break;
-      case 'oneOf':
-        out = '"oneOf" 스키마중 하나와 정확하게 일치해야 합니다';
-        break;
-      case 'pattern':
-        out = '"' + (e.params.pattern) + '"패턴과 일치해야 합니다';
-        break;
-      case 'patternRequired':
-        out = '"' + (e.params.missingPattern) + '"패턴과 일치하는 속성을 가져야 합니다';
-        break;
-      case 'propertyNames':
-        out = '\'' + (e.params.propertyName) + '\' 속성명이 올바르지 않습니다';
-        break;
-      case 'required':
-        out = '' + (e.params.missingProperty) + ' 속성은 필수입니다';
-        break;
-      case 'switch':
-        out = '"switch"키워드 검증에 실패하였습니다. ' + (e.params.caseIndex) + ' 실패';
-        break;
-      case 'type':
-        out = '' + (e.params.type) + '이여야 합니다';
-        break;
-      case 'uniqueItems':
-        out = '중복 아이템이 없어야 합니다 (아이템' + (e.params.j) + '과 아이템' + (e.params.i) + '가 동일합니다)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += " 항목은 아이템을 " + n + "개 이상 가질 수 없습니다"
+        break
+      case "additionalProperties":
+        out = "추가적인 속성은 허용되지 않습니다"
+        break
+      case "anyOf":
+        out = '"anyOf"의 스키마와 일치해야 합니다'
+        break
+      case "const":
+        out = "상수와 같아야합니다"
+        break
+      case "contains":
+        out = "올바른 아이템을 포함해야 합니다"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out +=
+          e.params.property +
+          "속성이 있는 경우, " +
+          e.params.deps +
+          " 속성이 있어야합니다"
+        break
+      case "enum":
+        out = "미리 정의된 값중 하나여야 합니다"
+        break
+      case "false schema":
+        out = "boolean 스키마는 올바르지 않습니다"
+        break
+      case "format":
+        out = '"' + e.params.format + '" 포맷과 일치해야 합니다'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " " + cond + " 이여야 합니다"
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " " + cond + " 이여야 합니다"
+        break
+      case "if":
+        out = '"' + e.params.failingKeyword + '" 스키마와 일치해야 합니다'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " " + cond + " 이여야 합니다"
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "아이템이 최대 " + n + "개이여야 합니다"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "최대 " + n + "글자여야 합니다"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "속성은 최대 " + n + "개 이내여야 합니다"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += " " + cond + " 이여야 합니다"
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "아이템이 최소 " + n + "개이여야 합니다"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "최소 " + n + "글자여야 합니다"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "속성은 최소 " + n + "개 이상이여야 합니다"
+        break
+      case "multipleOf":
+        out = "" + e.params.multipleOf + "의 배수여야 합니다"
+        break
+      case "not":
+        out = '"not"스키마에 따라 유효하지 않아야 합니다'
+        break
+      case "oneOf":
+        out = '"oneOf" 스키마중 하나와 정확하게 일치해야 합니다'
+        break
+      case "pattern":
+        out = '"' + e.params.pattern + '"패턴과 일치해야 합니다'
+        break
+      case "patternRequired":
+        out =
+          '"' +
+          e.params.missingPattern +
+          '"패턴과 일치하는 속성을 가져야 합니다'
+        break
+      case "propertyNames":
+        out = "속성명이 올바르지 않습니다"
+        break
+      case "required":
+        out = "" + e.params.missingProperty + " 속성은 필수입니다"
+        break
+      case "type":
+        out = "" + e.params.type + "이여야 합니다"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "중복 아이템이 없어야 합니다 (아이템" +
+          e.params.j +
+          "과 아이템" +
+          e.params.i +
+          "가 동일합니다)"
+        break
       default:
-        continue;
+        out = '"' + e.keyword + '"키워드 검사를 통과해야 합니다'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/nb/index.js

@@ -1,182 +0,184 @@
-'use strict';
+"use strict"
 module.exports = function localize_nb(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'kan ikke finne referansen ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke ha mer enn ' + (n) + ' element';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke ha mer enn " + n + " element"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'additionalProperties':
-        out = 'kan ikke ha flere egenskaper';
-        break;
-      case 'anyOf':
-        out = 'må samsvare med et schema i "anyOf"';
-        break;
-      case 'const':
-        out = 'må være lik konstanten';
-        break;
-      case 'contains':
-        out = 'må inneholde et gyldig element';
-        break;
-      case 'custom':
-        out = 'må samsvare med valideringen for ' + (e.keyword);
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'må ha egenskapen';
+        break
+      case "additionalProperties":
+        out = "kan ikke ha flere egenskaper"
+        break
+      case "anyOf":
+        out = 'må samsvare med et schema i "anyOf"'
+        break
+      case "const":
+        out = "må være lik konstanten"
+        break
+      case "contains":
+        out = "må inneholde et gyldig element"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "må ha egenskapen"
         if (n != 1) {
-          out += 'e';
+          out += "e"
         }
-        out += ' ' + (e.params.deps) + ' når egenskapen ' + (e.params.property) + ' er angitt';
-        break;
-      case 'enum':
-        out = 'må være lik en av de forhåndsdefinerte verdiene';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'false schema':
-        out = 'boolsk schema er usannt';
-        break;
-      case 'format':
-        out = 'må stemme overens med formatet "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum må være en boolsk verdi';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum må være en boolsk verdi';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke ha fler enn ' + (n) + ' element';
+        out +=
+          " " +
+          e.params.deps +
+          " når egenskapen " +
+          e.params.property +
+          " er angitt"
+        break
+      case "enum":
+        out = "må være lik en av de forhåndsdefinerte verdiene"
+        break
+      case "false schema":
+        out = "boolsk schema er usannt"
+        break
+      case "format":
+        out = 'må stemme overens med formatet "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "må være " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "må være " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "må være " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke ha fler enn " + n + " element"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke være lengre enn ' + (n) + ' tegn';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke ha mer enn ' + (n) + ' egenskap';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke være lengre enn " + n + " tegn"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke ha mer enn " + n + " egenskap"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'må være ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke ha færre enn ' + (n) + ' element';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "må være " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke ha færre enn " + n + " element"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke være kortere enn ' + (n) + ' tegn';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'kan ikke ha mindre enn ' + (n) + ' egenskap';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke være kortere enn " + n + " tegn"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "kan ikke ha mindre enn " + n + " egenskap"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'multipleOf':
-        out = 'må være et multiplum av ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'kan ikke samsvare med schema i "not"';
-        break;
-      case 'oneOf':
-        out = 'må samsvare med nøyaktig ett schema i "oneOf"';
-        break;
-      case 'pattern':
-        out = 'må samsvare med mønsteret "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'må ha en egenskap som samsvarer med mønsteret "' + (e.params.missingPattern);
-        break;
-      case 'propertyNames':
-        out = 'egenskapen med navnet \'';
-        e.params.propertyNameout += '\' er ugyldig';
-        break;
-      case 'required':
-        out = 'må ha den påkrevde egenskapen ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'må passere "switch" validering, tilfellet ' + (e.params.caseIndex) + ' misslykkes';
-        break;
-      case 'type':
-        out = '';
-        var t = e.params.type;
-        out += 'må være ';
+        break
+      case "multipleOf":
+        out = "må være et multiplum av " + e.params.multipleOf
+        break
+      case "not":
+        out = 'kan ikke samsvare med schema i "not"'
+        break
+      case "oneOf":
+        out = 'må samsvare med nøyaktig ett schema i "oneOf"'
+        break
+      case "pattern":
+        out = 'må samsvare med mønsteret "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'må ha en egenskap som samsvarer med mønsteret "' +
+          e.params.missingPattern
+        break
+      case "propertyNames":
+        out = "egenskapen med navnet '"
+        e.params.propertyNameout += "' er ugyldig"
+        break
+      case "required":
+        out = "må ha den påkrevde egenskapen " + e.params.missingProperty
+        break
+      case "type":
+        out = ""
+        var t = e.params.type
+        out += "må være "
         if (t == "number") {
-          out += 'et tall';
+          out += "et tall"
         } else if (t == "integer") {
-          out += 'et heltall';
+          out += "et heltall"
         } else if (t == "string") {
-          out += 'en streng';
+          out += "en streng"
         } else if (t == "boolean") {
-          out += 'ja eller nei';
+          out += "ja eller nei"
         } else {
-          out += (t);
+          out += t
         }
-        break;
-      case 'uniqueItems':
-        out = 'kan ikke ha duplikate elemeneter (elementene ## ' + (e.params.j) + ' og ' + (e.params.i) + ' er identiske)';
-        break;
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "kan ikke ha duplikate elemeneter (elementene ## " +
+          e.params.j +
+          " og " +
+          e.params.i +
+          " er identiske)"
+        break
       default:
-        continue;
+        out = "må samsvare med valideringen for " + e.keyword
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/nl/index.js

@@ -1,193 +0,203 @@
-'use strict';
+"use strict"
 module.exports = function localize_nl(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'referentie ' + (e.params.ref) + ' kon niet worden gevonden';
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet meer dan ' + (n) + ' item';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet meer dan " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' bevatten';
-        break;
-      case 'additionalProperties':
-        out = 'mag geen extra eigenschappen bevatten';
-        break;
-      case 'anyOf':
-        out = 'moet overeenkomen met een schema in "anyOf"';
-        break;
-      case 'const':
-        out = 'moet gelijk zijn aan constante';
-        break;
-      case 'contains':
-        out = 'moet een geldig item bevatten';
-        break;
-      case 'custom':
-        out = 'moet sleutelwoord validatie "' + (e.keyword) + '" doorstaan';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'moet de eigenschap';
+        out += " bevatten"
+        break
+      case "additionalProperties":
+        out = "mag geen extra eigenschappen bevatten"
+        break
+      case "anyOf":
+        out = 'moet overeenkomen met een schema in "anyOf"'
+        break
+      case "const":
+        out = "moet gelijk zijn aan constante"
+        break
+      case "contains":
+        out = "moet een geldig item bevatten"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "moet de eigenschap"
         if (n != 1) {
-          out += 'pen';
+          out += "pen"
         }
-        out += ' ' + (e.params.deps) + ' bevatten als ' + (e.params.property) + ' is gedefinieerd';
-        break;
-      case 'enum':
-        out = 'moet overeenkomen met één van de voorgedefinieerde waarden';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'false schema':
-        out = 'boolean schema is fout';
-        break;
-      case 'format':
-        out = 'moet overeenkomen met het voglende formaat: "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum moet een boolean zijn';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum moet een boolean zijn';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'if':
-        out = 'moet overeenkomen met "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet meer dan ' + (n) + ' item';
+        out +=
+          " " +
+          e.params.deps +
+          " bevatten als " +
+          e.params.property +
+          " is gedefinieerd"
+        break
+      case "enum":
+        out = "moet overeenkomen met één van de voorgedefinieerde waarden"
+        break
+      case "false schema":
+        out = "boolean schema is fout"
+        break
+      case "format":
+        out =
+          'moet overeenkomen met het volgende formaat: "' +
+          e.params.format +
+          '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "moet " + cond + " zijn"
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "moet " + cond + " zijn"
+        break
+      case "if":
+        out = 'moet overeenkomen met "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "moet " + cond + " zijn"
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet meer dan " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' bevatten';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet langer dan ' + (n) + ' karakter';
+        out += " bevatten"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet langer dan " + n + " karakter"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' zijn';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet meer dan ' + (n) + ' eigenschap';
+        out += " zijn"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet meer dan " + n + " eigenschap"
         if (n != 1) {
-          out += 'pen';
+          out += "pen"
         }
-        out += ' bevatten';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'moet ' + (cond) + ' zijn';
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet minder dan ' + (n) + ' item';
+        out += " bevatten"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "moet " + cond + " zijn"
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet minder dan " + n + " item"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' bevatten';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet korter dan ' + (n) + ' karakter';
+        out += " bevatten"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet korter dan " + n + " karakter"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' zijn';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'mag niet minder dan ' + (n) + ' eigenschap';
+        out += " zijn"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "mag niet minder dan " + n + " eigenschap"
         if (n != 1) {
-          out += 'pen';
+          out += "pen"
         }
-        out += ' bevatten';
-        break;
-      case 'multipleOf':
-        out = 'moet een veelvoud van ' + (e.params.multipleOf) + ' zijn';
-        break;
-      case 'not':
-        out = 'mag niet overeenkomen met een schema in "not"';
-        break;
-      case 'oneOf':
-        out = 'moet overeenkomen met één schema in "oneOf"';
-        break;
-      case 'pattern':
-        out = 'moet overeenkomen met het volgende patroon: "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'moet een eigenschap bevatten die overeenkomt met het pattroon: "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'eigenschapnaam \'' + (e.params.propertyName) + '\' is ongeldig';
-        break;
-      case 'required':
-        out = 'moet de eigenschap ' + (e.params.missingProperty) + ' bevatten';
-        break;
-      case 'switch':
-        out = 'moet "switch" sleutelwoord validatie doorstaan, ' + (e.params.caseIndex) + ' is ongeldig';
-        break;
-      case 'type':
-        out = '';
-        var t = e.params.type;
-        out += 'moet een ';
+        out += " bevatten"
+        break
+      case "multipleOf":
+        out = "moet een veelvoud van " + e.params.multipleOf + " zijn"
+        break
+      case "not":
+        out = 'mag niet overeenkomen met een schema in "not"'
+        break
+      case "oneOf":
+        out = 'moet overeenkomen met één schema in "oneOf"'
+        break
+      case "pattern":
+        out =
+          'moet overeenkomen met het volgende patroon: "' +
+          e.params.pattern +
+          '"'
+        break
+      case "patternRequired":
+        out =
+          'moet een eigenschap bevatten die overeenkomt met het pattroon: "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "eigenschapnaam is ongeldig"
+        break
+      case "required":
+        out = "moet de eigenschap " + e.params.missingProperty + " bevatten"
+        break
+      case "type":
+        out = ""
+        var t = e.params.type
+        out += "moet een "
         if (t == "number") {
-          out += 'nummer';
+          out += "nummer"
         } else if (t == "integer") {
-          out += 'geheel getal';
+          out += "geheel getal"
         } else if (t == "string") {
-          out += 'tekenreeks';
+          out += "tekenreeks"
         } else if (t == "boolean") {
-          out += 'ja of nee waarde';
+          out += "ja of nee waarde"
         }
-        out += ' (' + (t) + ') bevatten';
-        break;
-      case 'uniqueItems':
-        out = 'mag geen gedupliceerde items bevatten (items ## ' + (e.params.j) + ' en ' + (e.params.i) + ' zijn identiek)';
-        break;
+        out += " (" + t + ") bevatten"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "mag niet meer dan " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        out += " bevatten"
+        break
+      case "unevaluatedProperties":
+        out = "mag geen ongecontroleerde eigenschappen bevatten"
+        break
+      case "uniqueItems":
+        out =
+          "mag geen gedupliceerde items bevatten (items ## " +
+          e.params.j +
+          " en " +
+          e.params.i +
+          " zijn identiek)"
+        break
       default:
-        continue;
+        out = 'moet sleutelwoord validatie "' + e.keyword + '" doorstaan'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/pl/index.js

@@ -1,186 +0,189 @@
-'use strict';
+"use strict"
 module.exports = function localize_pl(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'nie można znaleść schematu ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien mieć więcej niż ' + (n) + ' element';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien mieć więcej niż " + n + " element"
         if (n == 1) {
-          out += 'u';
+          out += "u"
         } else {
-          out += 'ów';
+          out += "ów"
         }
-        break;
-      case 'additionalProperties':
-        out = 'nie powinien zawierać dodatkowych pól';
-        break;
-      case 'anyOf':
-        out = 'powinien pasować do wzoru z sekcji "anyOf"';
-        break;
-      case 'const':
-        out = 'powinien być równy stałej';
-        break;
-      case 'contains':
-        out = 'should contain a valid item';
-        break;
-      case 'custom':
-        out = 'powinien przejść walidację "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'powinien zawierać pol';
+        break
+      case "additionalProperties":
+        out = "nie powinien zawierać dodatkowych pól"
+        break
+      case "anyOf":
+        out = 'powinien pasować do wzoru z sekcji "anyOf"'
+        break
+      case "const":
+        out = "powinien być równy stałej"
+        break
+      case "contains":
+        out = "must contain a valid item"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "powinien zawierać pol"
         if (n == 1) {
-          out += 'e';
+          out += "e"
         } else {
-          out += 'a';
+          out += "a"
         }
-        out += ' ' + (e.params.deps) + ' kiedy pole ' + (e.params.property) + ' jest obecne';
-        break;
-      case 'enum':
-        out = 'powinien być równy jednej z predefiniowanych wartości';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'false schema':
-        out = 'boolean schema is false';
-        break;
-      case 'format':
-        out = 'powinien zgadzać się z formatem "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum powinien być boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum powinień być boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien mieć więcej niż ' + (n) + ' element';
+        out +=
+          " " +
+          e.params.deps +
+          " kiedy pole " +
+          e.params.property +
+          " jest obecne"
+        break
+      case "enum":
+        out = "powinien być równy jednej z predefiniowanych wartości"
+        break
+      case "false schema":
+        out = "boolean schema is false"
+        break
+      case "format":
+        out = 'powinien zgadzać się z formatem "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "powinien być " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "powinien być " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "powinien być " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien mieć więcej niż " + n + " element"
         if (n == 1) {
-          out += 'u';
+          out += "u"
         } else {
-          out += 'ów';
+          out += "ów"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien być dłuższy niż ' + (n) + ' znak';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien być dłuższy niż " + n + " znak"
         if (n != 1) {
-          out += 'ów';
+          out += "ów"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien zawierać więcej niż ' + (n) + ' ';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien zawierać więcej niż " + n + " "
         if (n == 1) {
-          out += 'pole';
+          out += "pole"
         } else {
-          out += 'pól';
+          out += "pól"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'powinien być ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien mieć mniej niż ' + (n) + ' element';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "powinien być " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien mieć mniej niż " + n + " element"
         if (n == 1) {
-          out += 'u';
+          out += "u"
         } else {
-          out += 'ów';
+          out += "ów"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien być krótszy niż ' + (n) + ' znak';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien być krótszy niż " + n + " znak"
         if (n != 1) {
-          out += 'ów';
+          out += "ów"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nie powinien zawierać mniej niż ' + (n) + ' ';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nie powinien zawierać mniej niż " + n + " "
         if (n == 1) {
-          out += 'pole';
+          out += "pole"
         } else {
-          out += 'pól';
+          out += "pól"
         }
-        break;
-      case 'multipleOf':
-        out = 'powinien być wielokrotnością ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'nie powinien pasować do wzoru z sekcji "not"';
-        break;
-      case 'oneOf':
-        out = 'powinien pasować do jednego wzoru z sekcji "oneOf"';
-        break;
-      case 'pattern':
-        out = 'powinien zgadzać się ze wzorem "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'powinien mieć pole pasujące do wzorca "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'property name \'' + (e.params.propertyName) + '\' is invalid';
-        break;
-      case 'required':
-        out = 'powinien zawierać wymagane pole ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'powinien przejść walidacje pola "switch", przypadek ' + (e.params.caseIndex) + ' zawiódł';
-        break;
-      case 'type':
-        out = 'powinien być ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'nie powinien zawierać elementów które się powtarzają (elementy ' + (e.params.j) + ' i ' + (e.params.i) + ' są identyczne)';
-        break;
+        break
+      case "multipleOf":
+        out = "powinien być wielokrotnością " + e.params.multipleOf
+        break
+      case "not":
+        out = 'nie powinien pasować do wzoru z sekcji "not"'
+        break
+      case "oneOf":
+        out = 'powinien pasować do jednego wzoru z sekcji "oneOf"'
+        break
+      case "pattern":
+        out = 'powinien zgadzać się ze wzorem "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'powinien mieć pole pasujące do wzorca "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "property name is invalid"
+        break
+      case "required":
+        out = "powinien zawierać wymagane pole " + e.params.missingProperty
+        break
+      case "type":
+        out = "powinien być " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "nie powinien zawierać elementów które się powtarzają (elementy " +
+          e.params.j +
+          " i " +
+          e.params.i +
+          " są identyczne)"
+        break
       default:
-        continue;
+        out = 'powinien przejść walidację "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/pt-BR/index.js

@@ -1,182 +0,187 @@
-'use strict';
+"use strict"
 module.exports = function localize_pt_BR(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'não é possível resolver a referência ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = 'não são permitidos itens adicionais';
-        break;
-      case 'additionalProperties':
-        out = 'não são permitidas propriedades adicionais';
-        break;
-      case 'anyOf':
-        out = 'os dados não correspondem a nenhum schema de "anyOf"';
-        break;
-      case 'const':
-        out = 'deve ser igual à constante';
-        break;
-      case 'contains':
-        out = 'deve conter um item válido';
-        break;
-      case 'custom':
-        out = 'deve passar a validação da keyword "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += ' deve ter propriedade ';
+      case "additionalItems":
+        out = "não são permitidos itens adicionais (mais do que " + n + ")"
+        break
+      case "additionalProperties":
+        out = "não são permitidas propriedades adicionais"
+        break
+      case "anyOf":
+        out = 'os dados não correspondem a nenhum schema de "anyOf"'
+        break
+      case "const":
+        out = "deve ser igual à constante"
+        break
+      case "contains":
+        out = "deve conter um item válido"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += " deve ter propriedade"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        out += ' ' + (e.params.deps) + ' quando a propriedade ' + (e.params.property) + ' estiver presente';
-        break;
-      case 'enum':
-        out = 'deve ser igual a um dos valores predefinidos';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'false schema':
-        out = 'o schema booleano é "false"';
-        break;
-      case 'format':
-        out = 'a validação do formato falhou "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum deve ser um booleano';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum deve ser um booleano';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'if':
-        out = 'deve corresponder ao schema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ter mais que ' + (n) + ' elemento';
+        out +=
+          " " +
+          e.params.deps +
+          " quando a propriedade " +
+          e.params.property +
+          " estiver presente"
+        break
+      case "enum":
+        out = "deve ser igual a um dos valores permitidos"
+        break
+      case "false schema":
+        out = 'o schema booleano é "false"'
+        break
+      case "format":
+        out = 'deve corresponder ao formato "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve ser " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve ser " + cond
+        break
+      case "if":
+        out = 'deve corresponder ao schema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve ser " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ter mais que " + n + " elemento"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ter mais que ' + (n) + ' caracter';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ser maior que " + n + " caracter"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ter mais que ' + (n) + ' propriedade';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ter mais que " + n + " propriedade"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'deve ser ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ter menos que ' + (n) + ' elemento';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "deve ser " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ter menos que " + n + " elemento"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ser mais curta que ' + (n) + ' caracter';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ser mais curta que " + n + " caracter"
         if (n != 1) {
-          out += 'es';
+          out += "es"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'não deve ter menos que ' + (n) + ' propriedade';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "não deve ter menos que " + n + " propriedade"
         if (n != 1) {
-          out += 's';
+          out += "s"
         }
-        break;
-      case 'multipleOf':
-        out = 'deve ser múltiplo de ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'não deve ser valido segundo o schema em "not"';
-        break;
-      case 'oneOf':
-        out = 'deve corresponder exatamente com um schema em "oneOf"';
-        break;
-      case 'pattern':
-        out = 'deve corresponder ao padrão "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'deve ter a propriedade correspondente ao padrão "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'o nome da propriedade \'' + (e.params.propertyName) + '\' é inválido';
-        break;
-      case 'required':
-        out = 'deve ter a propriedade obrigatória ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'deve passar a validação da keyword "switch", o caso ' + (e.params.caseIndex) + ' falha';
-        break;
-      case 'type':
-        out = '';
-        var t = e.params.type;
-        out += 'deve ser ';
+        break
+      case "multipleOf":
+        out = "deve ser múltiplo de " + e.params.multipleOf
+        break
+      case "not":
+        out = 'não deve ser valido segundo o schema em "not"'
+        break
+      case "oneOf":
+        out = 'deve corresponder exatamente com um schema em "oneOf"'
+        break
+      case "pattern":
+        out = 'deve corresponder ao padrão "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'deve ter a propriedade correspondente ao padrão "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "o nome da propriedade é inválido"
+        break
+      case "required":
+        out = "deve ter a propriedade obrigatória " + e.params.missingProperty
+        break
+      case "type":
+        out = ""
+        var t = e.params.type
+        out += "deve ser "
         if (t == "number") {
-          out += 'um número';
+          out += "um número"
         } else if (t == "integer") {
-          out += 'um número inteiro';
+          out += "um número inteiro"
         } else if (t == "string") {
-          out += 'um texto';
+          out += "um texto"
         } else if (t == "boolean") {
-          out += 'um booleano';
+          out += "um booleano"
         } else {
-          out += (t);
+          out += t
         }
-        break;
-      case 'uniqueItems':
-        out = 'não deve ter itens duplicados (os itens ## ' + (e.params.j) + ' e ' + (e.params.i) + ' são idênticos)';
-        break;
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "não pode possuir mais que " + n + " "
+        if (n == 1) {
+          out += "item"
+        } else {
+          out += "itens"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "não pode possuir propridades não avaliadas"
+        break
+      case "uniqueItems":
+        out =
+          "não deve ter itens duplicados (os itens ## " +
+          e.params.j +
+          " e " +
+          e.params.i +
+          " são idênticos)"
+        break
       default:
-        continue;
+        out = 'deve passar a validação da keyword "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/README.md

 This folder contains compiled localization functions.
 
-Do not edit these functions directly, edit [messages/index.js](https://github.com/epoberezkin/ajv-i18n/tree/master/messages/index.js).
+Do not edit `*.js` files directly, edit JSON Schema messages in [messages/index.js](https://github.com/epoberezkin/ajv-i18n/tree/master/messages/index.js) and JSON Type Definition messages in [messages/jtd.js](https://github.com/epoberezkin/ajv-i18n/tree/master/messages/jtd.js).
 
 If this folder doesn't have any locale sub-folders, run `npm run build`.

localize/ru/index.js

@@ -1,194 +0,195 @@
-'use strict';
+"use strict"
 module.exports = function localize_ru(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'не найдена схема ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно иметь не более, чем ' + (n) + ' элемент';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "должно иметь не более, чем " + n + " элемент"
         if (n >= 2 && n <= 4) {
-          out += 'а';
+          out += "а"
         } else if (n != 1) {
-          out += 'ов';
+          out += "ов"
         }
-        break;
-      case 'additionalProperties':
-        out = 'не должно иметь дополнительные поля';
-        break;
-      case 'anyOf':
-        out = 'должно соответствовать одной их схем в "anyOf"';
-        break;
-      case 'const':
-        out = 'должно быть равно заданному значению';
-        break;
-      case 'contains':
-        out = 'должно содержать значение соответствующее схеме';
-        break;
-      case 'custom':
-        out = 'должно соответствовать правилу "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'должно иметь пол';
+        break
+      case "additionalProperties":
+        out = "не должно иметь дополнительных полей"
+        break
+      case "anyOf":
+        out = 'должно соответствовать одной их схем в "anyOf"'
+        break
+      case "const":
+        out = "должно быть равно заданному значению"
+        break
+      case "contains":
+        out = "должно содержать значение соответствующее схеме"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "должно иметь пол"
         if (n == 1) {
-          out += 'е';
+          out += "е"
         } else {
-          out += 'я';
+          out += "я"
         }
-        out += ' ' + (e.params.deps) + ', когда присутствует поле ' + (e.params.property);
-        break;
-      case 'enum':
-        out = 'должно быть равен одному из значений в "enum"';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'false schema':
-        out = 'схема равна false';
-        break;
-      case 'format':
-        out = 'должно соответствовать формату "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum должно быть boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum должно быть boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'if':
-        out = 'должно соответствовать схемe "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно иметь не более, чем ' + (n) + ' элемент';
+        out +=
+          " " + e.params.deps + ", когда присутствует поле " + e.params.property
+        break
+      case "enum":
+        out = "должно быть равно одному из разрешенных значений"
+        break
+      case "false schema":
+        out = "схема равна false"
+        break
+      case "format":
+        out = 'должно соответствовать формату "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "должно быть " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "должно быть " + cond
+        break
+      case "if":
+        out = 'должно соответствовать схемe "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "должно быть " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "должно иметь не более, чем " + n + " элемент"
         if (n >= 2 && n <= 4) {
-          out += 'а';
+          out += "а"
         } else if (n != 1) {
-          out += 'ов';
+          out += "ов"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно быть не длиннее, чем ' + (n) + ' символ';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "должно быть не длиннее, чем " + n + " символ"
         if (n >= 2 && n <= 4) {
-          out += 'а';
+          out += "а"
         } else if (n != 1) {
-          out += 'ов';
+          out += "ов"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно иметь не более, чем ' + (n) + ' пол';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "должно иметь не более, чем " + n + " пол"
         if (n == 1) {
-          out += 'е';
+          out += "е"
         } else if (n >= 2 && n <= 4) {
-          out += 'я';
+          out += "я"
         } else {
-          out += 'ей';
+          out += "ей"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'должно быть ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно иметь не менее, чем ' + (n) + ' элемент';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "должно быть " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "должно иметь не менее, чем " + n + " элемент"
         if (n >= 2 && n <= 4) {
-          out += 'а';
+          out += "а"
         } else if (n != 1) {
-          out += 'ов';
+          out += "ов"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно быть не короче, чем ' + (n) + ' символ';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "должно быть не короче, чем " + n + " символ"
         if (n >= 2 && n <= 4) {
-          out += 'а';
+          out += "а"
         } else if (n != 1) {
-          out += 'ов';
+          out += "ов"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'должно иметь не менее, чем ' + (n) + ' пол';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "должно иметь не менее, чем " + n + " пол"
         if (n == 1) {
-          out += 'е';
+          out += "е"
         } else if (n >= 2 && n <= 4) {
-          out += 'я';
+          out += "я"
         } else {
-          out += 'ей';
+          out += "ей"
         }
-        break;
-      case 'multipleOf':
-        out = 'должно быть кратным ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'должно не соответствовать схеме в "not"';
-        break;
-      case 'oneOf':
-        out = 'должно соответствовать в точности одной схемe в "oneOf"';
-        break;
-      case 'pattern':
-        out = 'должно соответствовать образцу "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'должно иметь поле, соответствующее образцу "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'имя поля \'' + (e.params.propertyName) + '\' не соответствует схеме';
-        break;
-      case 'required':
-        out = 'должно иметь обязательное поле ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'должно соответствовать правилу ' + (e.params.caseIndex) + ' в "switch"';
-        break;
-      case 'type':
-        out = 'должно быть ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'не должно иметь повторяющихся элементов (элементы ' + (e.params.j) + ' и ' + (e.params.i) + ' идентичны)';
-        break;
+        break
+      case "multipleOf":
+        out = "должно быть кратным " + e.params.multipleOf
+        break
+      case "not":
+        out = 'должно не соответствовать схеме в "not"'
+        break
+      case "oneOf":
+        out = 'должно соответствовать в точности одной схемe в "oneOf"'
+        break
+      case "pattern":
+        out = 'должно соответствовать образцу "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'должно иметь поле, соответствующее образцу "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "имя поля не соответствует схеме"
+        break
+      case "required":
+        out = "должно иметь обязательное поле " + e.params.missingProperty
+        break
+      case "type":
+        out = "должно быть " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "должно иметь не более, чем " + n + " элемент"
+        if (n >= 2 && n <= 4) {
+          out += "а"
+        } else if (n != 1) {
+          out += "ов"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "не должно иметь непроверенных полей"
+        break
+      case "uniqueItems":
+        out =
+          "не должно иметь повторяющихся элементов (элементы " +
+          e.params.j +
+          " и " +
+          e.params.i +
+          " идентичны)"
+        break
       default:
-        continue;
+        out = 'должно соответствовать правилу "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/sk/index.js

@@ -1,192 +0,190 @@
-'use strict';
+"use strict"
 module.exports = function localize_sk(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'referenciu ' + (e.params.ref) + ' sa nepodarilo nájsť';
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nemôže obsahovať viac, než ' + (n) + ' prv';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "nemôže obsahovať viac, než " + n + " prv"
         if (n == 1) {
-          out += 'ok';
+          out += "ok"
         } else {
-          out += 'kov';
+          out += "kov"
         }
-        break;
-      case 'additionalProperties':
-        out = 'nemôže obsahovať ďalšie položky';
-        break;
-      case 'anyOf':
-        out = 'musí splňovať aspoň jednu zo schém v "anyOf"';
-        break;
-      case 'const':
-        out = 'musí byť konštanta';
-        break;
-      case 'contains':
-        out = 'musí obsahovať prvok zodpovedajúci schéme';
-        break;
-      case 'custom':
-        out = 'musí splniť "' + (e.keyword) + '" validáciu';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += ' musí obsahovať polož';
+        break
+      case "additionalProperties":
+        out = "nemôže obsahovať ďalšie položky"
+        break
+      case "anyOf":
+        out = 'musí splňovať aspoň jednu zo schém v "anyOf"'
+        break
+      case "const":
+        out = "musí byť konštanta"
+        break
+      case "contains":
+        out = "musí obsahovať prvok zodpovedajúci schéme"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += " musí obsahovať polož"
         if (n >= 2 && n <= 4) {
-          out += 'ky';
+          out += "ky"
         } else if (n != 1) {
-          out += 'iek';
+          out += "iek"
         } else {
-          out += 'ka';
+          out += "ka"
         }
-        out += ': ' + (e.params.deps) + ', ak obsahuje ' + (e.params.property);
-        break;
-      case 'enum':
-        out = 'musí byť jedna z definovaných hodnôt';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'false schema':
-        out = 'schéma je false';
-        break;
-      case 'format':
-        out = 'musí obsahovať formát "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum musí byť boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum musí byť boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie obsahovať viac než ' + (n) + ' prv';
+        out += ": " + e.params.deps + ", ak obsahuje " + e.params.property
+        break
+      case "enum":
+        out = "musí byť jedna z definovaných hodnôt"
+        break
+      case "false schema":
+        out = "schéma je false"
+        break
+      case "format":
+        out = 'musí obsahovať formát "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "musí byť " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "musí byť " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "musí byť " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie obsahovať viac než " + n + " prv"
         if (n == 1) {
-          out += 'ok';
+          out += "ok"
         } else {
-          out += 'kov';
+          out += "kov"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie byť dlhší než ' + (n) + ' znak';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie byť dlhší než " + n + " znak"
         if (n != 1) {
-          out += 'ov';
+          out += "ov"
         }
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie obsahovať viac než ' + (n) + ' polož';
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie obsahovať viac než " + n + " polož"
         if (n >= 2 && n <= 4) {
-          out += 'ky';
+          out += "ky"
         } else if (n != 1) {
-          out += 'iek';
+          out += "iek"
         } else {
-          out += 'ka';
+          out += "ka"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'musí byť ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie obsahovať menej než ' + (n) + ' prv';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "musí byť " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie obsahovať menej než " + n + " prv"
         if (n == 1) {
-          out += 'ok';
+          out += "ok"
         } else {
-          out += 'kov';
+          out += "kov"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie byť kratší než ' + (n) + ' znak';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie byť kratší než " + n + " znak"
         if (n != 1) {
-          out += 'ov';
+          out += "ov"
         }
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'nesmie obsahovať menej než ' + (n) + ' polož';
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "nesmie obsahovať menej než " + n + " polož"
         if (n >= 2 && n <= 4) {
-          out += 'ky';
+          out += "ky"
         } else if (n != 1) {
-          out += 'iek';
+          out += "iek"
         } else {
-          out += 'ka';
+          out += "ka"
         }
-        break;
-      case 'multipleOf':
-        out = 'musí byť násobkom ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'nesmie splňovať schému v "not"';
-        break;
-      case 'oneOf':
-        out = 'musí splňovať práve jednu schému v "oneOf"';
-        break;
-      case 'pattern':
-        out = 'musí splňovať regulárny výraz "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'musí obsahovať položku splňjúcu regulárny výraz "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'názov položky \'' + (e.params.propertyName) + '\' nezodpovedá schéme';
-        break;
-      case 'required':
-        out = 'musí obsahovať požadovanú položku ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'musí prejsť validáciou "switch", prípad ' + (e.params.caseIndex) + ' je neúspešný';
-        break;
-      case 'type':
-        out = 'musí byť ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'nesmie obsahovať duplicitné prvky (prvky ## ' + (e.params.j) + ' a ' + (e.params.i) + ' sú rovnaké)';
-        break;
+        break
+      case "multipleOf":
+        out = "musí byť násobkom " + e.params.multipleOf
+        break
+      case "not":
+        out = 'nesmie splňovať schému v "not"'
+        break
+      case "oneOf":
+        out = 'musí splňovať práve jednu schému v "oneOf"'
+        break
+      case "pattern":
+        out = 'musí splňovať regulárny výraz "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'musí obsahovať položku splňjúcu regulárny výraz "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "názov položky nezodpovedá schéme"
+        break
+      case "required":
+        out = "musí obsahovať požadovanú položku " + e.params.missingProperty
+        break
+      case "type":
+        out = "musí byť " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "nesmie obsahovať duplicitné prvky (prvky ## " +
+          e.params.j +
+          " a " +
+          e.params.i +
+          " sú rovnaké)"
+        break
       default:
-        continue;
+        out = 'musí splniť "' + e.keyword + '" validáciu'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/sv/index.js

@@ -1,168 +0,171 @@
-'use strict';
+"use strict"
 module.exports = function localize_sv(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'kan inte lösa referens ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde ha fler än ' + (n) + ' sak';
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "borde ha fler än " + n + " sak"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'additionalProperties':
-        out = 'borde inte ha fler egenskaper';
-        break;
-      case 'anyOf':
-        out = 'borde matcha något schema i "anyOf"';
-        break;
-      case 'const':
-        out = 'bör vara en konstant';
-        break;
-      case 'contains':
-        out = 'bör innehålla ett giltigt objekt';
-        break;
-      case 'custom':
-        out = 'bör passera "' + (e.keyword) + '" nyckelord validering';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'borde ha egenskap';
+        break
+      case "additionalProperties":
+        out = "borde inte ha fler egenskaper"
+        break
+      case "anyOf":
+        out = 'borde matcha något schema i "anyOf"'
+        break
+      case "const":
+        out = "bör vara en konstant"
+        break
+      case "contains":
+        out = "bör innehålla ett giltigt objekt"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "borde ha egenskap"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        out += ' ' + (e.params.deps) + ' när egenskap ' + (e.params.property) + ' finns tillgängligt';
-        break;
-      case 'enum':
-        out = 'borde vara ekvivalent med en av dess fördefinierade värden';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'borde vara ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'borde vara ' + (cond);
-        break;
-      case 'false schema':
-        out = 'boolean schema är falskt';
-        break;
-      case 'format':
-        out = 'borde matcha formatet "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum bör vara en boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMaximum bör vara en boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'bör vara ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'bör vara ' + (cond);
-        break;
-      case 'if':
-        out = 'should match "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'borde vara ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte ha fler än ' + (n) + ' sak';
+        out +=
+          " " +
+          e.params.deps +
+          " när egenskap " +
+          e.params.property +
+          " finns tillgängligt"
+        break
+      case "enum":
+        out = "borde vara ekvivalent med en av dess fördefinierade värden"
+        break
+      case "false schema":
+        out = "boolean schema är falskt"
+        break
+      case "format":
+        out = 'borde matcha formatet "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "bör vara " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "bör vara " + cond
+        break
+      case "if":
+        out = 'must match "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "borde vara " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte ha fler än " + n + " sak"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte vara längre än ' + (n) + ' tecken';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte ha fler än ' + (n) + ' egenskap';
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte vara längre än " + n + " tecken"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte ha fler än " + n + " egenskap"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'borde vara ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte ha färre än ' + (n) + ' sak';
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "borde vara " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte ha färre än " + n + " sak"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte vara kortare än ' + (n) + ' tecken';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'borde inte ha färre än ' + (n) + ' egenskap';
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte vara kortare än " + n + " tecken"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "borde inte ha färre än " + n + " egenskap"
         if (n != 1) {
-          out += 'er';
+          out += "er"
         }
-        break;
-      case 'multipleOf':
-        out = 'borde vara en multipel av ' + (e.params.multipleOf);
-        break;
-      case 'not':
-        out = 'borde inte vara giltigt enligt schema i "not"';
-        break;
-      case 'oneOf':
-        out = 'borde matcha exakt ett schema i "oneOf"';
-        break;
-      case 'pattern':
-        out = 'borde matcha mönstret "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'bör ha en egenskap som matchar mönstret "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'egenskap med namnet \'' + (e.params.propertyName) + '\' är inte giltig';
-        break;
-      case 'required':
-        out = 'borde ha den nödvändiga egenskapen ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = 'bör passera "switch" nyckelord validering, fallet ' + (e.params.caseIndex) + ' misslyckas';
-        break;
-      case 'type':
-        out = 'borde vara ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'borde inte ha duplicerade saker (sakerna ## ' + (e.params.j) + ' och ' + (e.params.i) + ' är identiska)';
-        break;
+        break
+      case "multipleOf":
+        out = "borde vara en multipel av " + e.params.multipleOf
+        break
+      case "not":
+        out = 'borde inte vara giltigt enligt schema i "not"'
+        break
+      case "oneOf":
+        out = 'borde matcha exakt ett schema i "oneOf"'
+        break
+      case "pattern":
+        out = 'borde matcha mönstret "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'bör ha en egenskap som matchar mönstret "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "egenskap med namnet är inte giltig"
+        break
+      case "required":
+        out = "borde ha den nödvändiga egenskapen " + e.params.missingProperty
+        break
+      case "type":
+        out = "borde vara " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "must NOT have more than " + n + " item"
+        if (n != 1) {
+          out += "s"
+        }
+        break
+      case "unevaluatedProperties":
+        out = "must NOT have unevaluated properties"
+        break
+      case "uniqueItems":
+        out =
+          "borde inte ha duplicerade saker (sakerna ## " +
+          e.params.j +
+          " och " +
+          e.params.i +
+          " är identiska)"
+        break
       default:
-        continue;
+        out = 'bör passera "' + e.keyword + '" nyckelord validering'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/th/index.js

@@ -1,149 +0,149 @@
-'use strict';
+"use strict"
 module.exports = function localize_th(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = 'ไม่สามารถหา reference ' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ควรมีสมาชิกไม่เกิน ' + (n);
-        break;
-      case 'additionalProperties':
-        out = 'ไม่ควรมี property เกินที่กำหนดไว้';
-        break;
-      case 'anyOf':
-        out = 'ควรมี schema บางอย่างตรงกับที่กำหนดไว้ใน "anyOf"';
-        break;
-      case 'const':
-        out = 'ควรมีค่าเหมือนกับค่าคงที่';
-        break;
-      case 'contains':
-        out = 'ควรมีสมาชิกที่ถูกต้องอยู่';
-        break;
-      case 'custom':
-        out = 'ควรผ่านคีย์เวิร์ด "' + (e.keyword) + '"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += 'เมื่อมี property ' + (e.params.property) + ' แล้วก็ควรมี property ' + (e.params.deps) + ' ด้วย';
-        break;
-      case 'enum':
-        out = 'ควรตรงกับค่าที่กำหนดไว้';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'false schema':
-        out = 'schema เป็น false';
-        break;
-      case 'format':
-        out = 'ควรมีรูปแบบเป็น "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum ควรเป็น boolean';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum ควรเป็น boolean';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'if':
-        out = 'ควรตรงกับ schema "' + (e.params.failingKeyword) + '"';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ควรมีสมาชิกไม่เกิน ' + (n);
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'ไม่ควรมากกว่า ' + (n) + ' ตัวอักษร';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'ไม่ควรมี property เกิน ' + (n);
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += 'ควร ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += 'ควรมีสมาชิกไม่น้อยกว่า ' + (n);
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += 'ไม่ควรน้อยกว่า ' + (n) + ' ตัวอักษร';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += 'ไม่ควรมี property น้อยกว่า ' + (n);
-        break;
-      case 'multipleOf':
-        out = 'ควรเป็นเลขที่หาร ' + (e.params.multipleOf) + ' ลงตัว';
-        break;
-      case 'not':
-        out = 'ไม่ควรถูกต้องตาม schema ที่กำหนดไว้ใน "not"';
-        break;
-      case 'oneOf':
-        out = 'ควรตรงกับเพียง schema เดียวใน "oneOf" เท่านั้น';
-        break;
-      case 'pattern':
-        out = 'ควรตรงกับแพทเทิร์น "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = 'ควรมี property ที่มีชื่อตรงกับ pattern "' + (e.params.missingPattern) + '"';
-        break;
-      case 'propertyNames':
-        out = 'property \'' + (e.params.propertyName) + '\' ไม่ถูกต้อง';
-        break;
-      case 'required':
-        out = 'ควรมี property ' + (e.params.missingProperty) + ' ที่บังคับไว้';
-        break;
-      case 'switch':
-        out = 'ควรผ่านคีย์เวิร์ด "switch", ผิดเคสที่ ' + (e.params.caseIndex);
-        break;
-      case 'type':
-        out = 'ควรเป็น ' + (e.params.type);
-        break;
-      case 'uniqueItems':
-        out = 'ไม่ควรมีสมาชิกซ้ำักัน (ลำดับที่ ' + (e.params.j) + ' และ ' + (e.params.i) + ' ซ้ำ)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องมีสมาชิกไม่เกิน " + n + " ตัว"
+        break
+      case "additionalProperties":
+        out = "ต้องไม่มี property อื่นๆ นอกเหนีอจากที่กำหนดไว้"
+        break
+      case "anyOf":
+        out = 'ต้องตรงกับหนึ่งใน schema ที่กำหนดไว้ใน "anyOf"'
+        break
+      case "const":
+        out = "ต้องเท่ากับค่าคงที่"
+        break
+      case "contains":
+        out = "ต้องมีสมาชิกที่ผ่านเงื่อนไขอยู่"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out +=
+          "เมื่อมี property " +
+          e.params.property +
+          " แล้วจะต้องมี property " +
+          e.params.deps +
+          " ด้วย"
+        break
+      case "enum":
+        out = "ต้องตรงกับหนึ่งในค่าที่กำหนดไว้"
+        break
+      case "false schema":
+        out = "schema เป็น false"
+        break
+      case "format":
+        out = 'ต้องเป็นรูปแบบ "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ต้อง " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ต้อง " + cond
+        break
+      case "if":
+        out = 'ต้องตรงกับ schema "' + e.params.failingKeyword + '"'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ต้อง " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องมีสมาชิกไม่เกิน " + n
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องยาวไม่เกิน " + n + " ตัวอักษร"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องมี property ไม่เกิน " + n + " ตัว"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "ต้อง " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "ควรมีสมาชิกไม่น้อยกว่า " + n
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องมีอย่างน้อย " + n + " ตัวอักษร"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "ต้องมี property อย่างน้อย " + n + " ตัว"
+        break
+      case "multipleOf":
+        out = "ต้องเป็นเลขที่หาร " + e.params.multipleOf + " ลงตัว"
+        break
+      case "not":
+        out = 'ต้องไม่ผ่าน schema ที่กำหนดไว้ใน "not"'
+        break
+      case "oneOf":
+        out = 'ต้องตรงกับ schema ตัวเดียวใน "oneOf" เท่านั้น'
+        break
+      case "pattern":
+        out = 'ต้องตรงตาม pattern "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out =
+          'ต้องมี property ที่มีชื่อตรงตาม pattern "' +
+          e.params.missingPattern +
+          '"'
+        break
+      case "propertyNames":
+        out = "ชื่อ property ไม่ถูกต้อง"
+        break
+      case "required":
+        out = "ต้องมี property " + e.params.missingProperty + " ด้วย"
+        break
+      case "type":
+        out = "ต้องเป็น " + e.params.type
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += "ต้องมีไม่เกิน " + n + " ตัว"
+        break
+      case "unevaluatedProperties":
+        out = "ต้องไม่มี property ที่ยังไม่ได้ผ่านการตรวจสอบเงื่อนไขใดๆ"
+        break
+      case "uniqueItems":
+        out =
+          "ต้องมีสมาชิกไม่ซ้ำักัน (ลำดับที่ " +
+          e.params.j +
+          " กับ " +
+          e.params.i +
+          " ซ้ำกัน)"
+        break
       default:
-        continue;
+        out = 'ต้องผ่านคีย์เวิร์ด "' + e.keyword + '"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/zh-TW/index.js

@@ -1,149 +0,141 @@
-'use strict';
+"use strict"
 module.exports = function localize_zh_TW(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = '無法找到引用' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不可以超過' + (n) + '個元素';
-        break;
-      case 'additionalProperties':
-        out = '不可以有額外的屬性';
-        break;
-      case 'anyOf':
-        out = '不符合 anyOf 指定的模式';
-        break;
-      case 'const':
-        out = '應該等於常數';
-        break;
-      case 'contains':
-        out = '應該包含一個有效元素';
-        break;
-      case 'custom':
-        out = '應該通過 "' + (e.keyword) + ' 關鍵詞檢驗"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += '應該要有屬性' + (e.params.property) + '的依賴屬性' + (e.params.deps);
-        break;
-      case 'enum':
-        out = '應該要在預設的值之中';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該要 ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該要 ' + (cond);
-        break;
-      case 'false schema':
-        out = '布林模式不正確';
-        break;
-      case 'format':
-        out = '應該要符合' + (e.params.format) + '格式';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum 應該是布林值';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum 應該是布林值';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該是 ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該是 ' + (cond);
-        break;
-      case 'if':
-        out = '應該符合 "' + (e.params.failingKeyword) + '" schema';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該要 ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該多於 ' + (n) + ' 個';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該多於 ' + (n) + ' 個字元';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該多於 ' + (n) + ' 個屬性';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '應該要 ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該少於 ' + (n) + ' 個';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該少於 ' + (n) + ' 個字元';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '不應該少於 ' + (n) + ' 個屬性';
-        break;
-      case 'multipleOf':
-        out = '應該是 ' + (e.params.multipleOf) + ' 的整數倍';
-        break;
-      case 'not':
-        out = '不應該符合 "not" schema';
-        break;
-      case 'oneOf':
-        out = '只能符合一個 "oneOf" 中的 schema';
-        break;
-      case 'pattern':
-        out = '應該符合模式 "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = '應該有屬性對應模式 ' + (e.params.missingPattern);
-        break;
-      case 'propertyNames':
-        out = '属性名 \'' + (e.params.propertyName) + '\' 無效';
-        break;
-      case 'required':
-        out = '應該有必須屬性 ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = '因為 ' + (e.params.caseIndex) + ' 失败，沒有通過 "switch" 檢驗, ';
-        break;
-      case 'type':
-        out = '應該是 ' + (e.params.type) + ' 類型';
-        break;
-      case 'uniqueItems':
-        out = '不應該有重複項目 (第 ' + (e.params.j) + ' 項和第 ' + (e.params.i) + ' 項是重複的)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "不可以超過" + n + "個元素"
+        break
+      case "additionalProperties":
+        out = "不可以有額外的屬性"
+        break
+      case "anyOf":
+        out = "不符合 anyOf 指定的模式"
+        break
+      case "const":
+        out = "應該等於常數"
+        break
+      case "contains":
+        out = "應該包含一個有效元素"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "應該要有屬性" + e.params.property + "的依賴屬性" + e.params.deps
+        break
+      case "enum":
+        out = "應該要在預設的值之中"
+        break
+      case "false schema":
+        out = "布林模式不正確"
+        break
+      case "format":
+        out = "應該要符合" + e.params.format + "格式"
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "應該是 " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "應該是 " + cond
+        break
+      case "if":
+        out = '應該符合 "' + e.params.failingKeyword + '" schema'
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "應該要 " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "不應該多於 " + n + " 個"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "不應該多於 " + n + " 個字元"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "不應該多於 " + n + " 個屬性"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "應該要 " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "不應該少於 " + n + " 個"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "不應該少於 " + n + " 個字元"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "不應該少於 " + n + " 個屬性"
+        break
+      case "multipleOf":
+        out = "應該是 " + e.params.multipleOf + " 的整數倍"
+        break
+      case "not":
+        out = '不應該符合 "not" schema'
+        break
+      case "oneOf":
+        out = '只能符合一個 "oneOf" 中的 schema'
+        break
+      case "pattern":
+        out = '應該符合模式 "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out = "應該有屬性對應模式 " + e.params.missingPattern
+        break
+      case "propertyNames":
+        out = "属性名 無效"
+        break
+      case "required":
+        out = "應該有必須屬性 " + e.params.missingProperty
+        break
+      case "type":
+        out = "應該是 " + e.params.type + " 類型"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += " 的元素不可以超過 " + n + " 個"
+        break
+      case "unevaluatedProperties":
+        out = "不應該有未驗證的屬性"
+        break
+      case "uniqueItems":
+        out =
+          "不應該有重複項目 (第 " +
+          e.params.j +
+          " 項和第 " +
+          e.params.i +
+          " 項是重複的)"
+        break
       default:
-        continue;
+        out = '應該通過 "' + e.keyword + ' 關鍵詞檢驗"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

localize/zh/index.js

@@ -1,149 +0,141 @@
-'use strict';
+"use strict"
 module.exports = function localize_zh(errors) {
-  if (!(errors && errors.length)) return;
-  for (var i = 0; i < errors.length; i++) {
-    var e = errors[i];
-    var out;
+  if (!(errors && errors.length)) return
+  for (const e of errors) {
+    let out
     switch (e.keyword) {
-      case '$ref':
-        out = '无法找到引用' + (e.params.ref);
-        break;
-      case 'additionalItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不允许超过' + (n) + '个元素';
-        break;
-      case 'additionalProperties':
-        out = '不允许有额外的属性';
-        break;
-      case 'anyOf':
-        out = '数据应为 anyOf 所指定的其中一个';
-        break;
-      case 'const':
-        out = '应当等于常量';
-        break;
-      case 'contains':
-        out = '应当包含一个有效项';
-        break;
-      case 'custom':
-        out = '应当通过 "' + (e.keyword) + ' 关键词校验"';
-        break;
-      case 'dependencies':
-        out = '';
-        var n = e.params.depsCount;
-        out += '应当拥有属性' + (e.params.property) + '的依赖属性' + (e.params.deps);
-        break;
-      case 'enum':
-        out = '应当是预设定的枚举值之一';
-        break;
-      case 'exclusiveMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当为 ' + (cond);
-        break;
-      case 'exclusiveMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当为 ' + (cond);
-        break;
-      case 'false schema':
-        out = '布尔模式出错';
-        break;
-      case 'format':
-        out = '应当匹配格式 "' + (e.params.format) + '"';
-        break;
-      case 'formatExclusiveMaximum':
-        out = 'formatExclusiveMaximum 应当是布尔值';
-        break;
-      case 'formatExclusiveMinimum':
-        out = 'formatExclusiveMinimum 应当是布尔值';
-        break;
-      case 'formatMaximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当是 ' + (cond);
-        break;
-      case 'formatMinimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当是 ' + (cond);
-        break;
-      case 'if':
-        out = '应当匹配模式 "' + (e.params.failingKeyword) + '" ';
-        break;
-      case 'maximum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当为 ' + (cond);
-        break;
-      case 'maxItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不应多于 ' + (n) + ' 个项';
-        break;
-      case 'maxLength':
-        out = '';
-        var n = e.params.limit;
-        out += '不应多于 ' + (n) + ' 个字符';
-        break;
-      case 'maxProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '不应有多于 ' + (n) + ' 个属性';
-        break;
-      case 'minimum':
-        out = '';
-        var cond = e.params.comparison + " " + e.params.limit;
-        out += '应当为 ' + (cond);
-        break;
-      case 'minItems':
-        out = '';
-        var n = e.params.limit;
-        out += '不应少于 ' + (n) + ' 个项';
-        break;
-      case 'minLength':
-        out = '';
-        var n = e.params.limit;
-        out += '不应少于 ' + (n) + ' 个字符';
-        break;
-      case 'minProperties':
-        out = '';
-        var n = e.params.limit;
-        out += '不应有少于 ' + (n) + ' 个属性';
-        break;
-      case 'multipleOf':
-        out = '应当是 ' + (e.params.multipleOf) + ' 的整数倍';
-        break;
-      case 'not':
-        out = '不应当匹配 "not" schema';
-        break;
-      case 'oneOf':
-        out = '只能匹配一个 "oneOf" 中的 schema';
-        break;
-      case 'pattern':
-        out = '应当匹配模式 "' + (e.params.pattern) + '"';
-        break;
-      case 'patternRequired':
-        out = '应当有属性匹配模式 ' + (e.params.missingPattern);
-        break;
-      case 'propertyNames':
-        out = '属性名 \'' + (e.params.propertyName) + '\' 无效';
-        break;
-      case 'required':
-        out = '应当有必需属性 ' + (e.params.missingProperty);
-        break;
-      case 'switch':
-        out = '由于 ' + (e.params.caseIndex) + ' 失败，未通过 "switch" 校验, ';
-        break;
-      case 'type':
-        out = '应当是 ' + (e.params.type) + ' 类型';
-        break;
-      case 'uniqueItems':
-        out = '不应当含有重复项 (第 ' + (e.params.j) + ' 项与第 ' + (e.params.i) + ' 项是重复的)';
-        break;
+      case "additionalItems":
+        out = ""
+        var n = e.params.limit
+        out += "不允许超过" + n + "个元素"
+        break
+      case "additionalProperties":
+        out = "不允许有额外的属性"
+        break
+      case "anyOf":
+        out = "数据应为 anyOf 所指定的其中一个"
+        break
+      case "const":
+        out = "应当等于常量"
+        break
+      case "contains":
+        out = "应当包含一个有效项"
+        break
+      case "dependencies":
+      case "dependentRequired":
+        out = ""
+        var n = e.params.depsCount
+        out += "应当拥有属性" + e.params.property + "的依赖属性" + e.params.deps
+        break
+      case "enum":
+        out = "应当是预设定的枚举值之一"
+        break
+      case "false schema":
+        out = "布尔模式出错"
+        break
+      case "format":
+        out = '应当匹配格式 "' + e.params.format + '"'
+        break
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "应当是 " + cond
+        break
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "应当是 " + cond
+        break
+      case "if":
+        out = '应当匹配模式 "' + e.params.failingKeyword + '" '
+        break
+      case "maximum":
+      case "exclusiveMaximum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "应当为 " + cond
+        break
+      case "maxItems":
+        out = ""
+        var n = e.params.limit
+        out += "不应多于 " + n + " 个项"
+        break
+      case "maxLength":
+        out = ""
+        var n = e.params.limit
+        out += "不应多于 " + n + " 个字符"
+        break
+      case "maxProperties":
+        out = ""
+        var n = e.params.limit
+        out += "不应有多于 " + n + " 个属性"
+        break
+      case "minimum":
+      case "exclusiveMinimum":
+        out = ""
+        var cond = e.params.comparison + " " + e.params.limit
+        out += "应当为 " + cond
+        break
+      case "minItems":
+        out = ""
+        var n = e.params.limit
+        out += "不应少于 " + n + " 个项"
+        break
+      case "minLength":
+        out = ""
+        var n = e.params.limit
+        out += "不应少于 " + n + " 个字符"
+        break
+      case "minProperties":
+        out = ""
+        var n = e.params.limit
+        out += "不应有少于 " + n + " 个属性"
+        break
+      case "multipleOf":
+        out = "应当是 " + e.params.multipleOf + " 的整数倍"
+        break
+      case "not":
+        out = '不应当匹配 "not" schema'
+        break
+      case "oneOf":
+        out = '只能匹配一个 "oneOf" 中的 schema'
+        break
+      case "pattern":
+        out = '应当匹配模式 "' + e.params.pattern + '"'
+        break
+      case "patternRequired":
+        out = "应当有属性匹配模式 " + e.params.missingPattern
+        break
+      case "propertyNames":
+        out = "属性名 无效"
+        break
+      case "required":
+        out = "应当有必需属性 " + e.params.missingProperty
+        break
+      case "type":
+        out = "应当是 " + e.params.type + " 类型"
+        break
+      case "unevaluatedItems":
+        out = ""
+        var n = e.params.len
+        out += " 不允许有超过 " + n + " 个元素"
+        break
+      case "unevaluatedProperties":
+        out = "不允许存在未求值的属性"
+        break
+      case "uniqueItems":
+        out =
+          "不应当含有重复项 (第 " +
+          e.params.j +
+          " 项与第 " +
+          e.params.i +
+          " 项是重复的)"
+        break
       default:
-        continue;
+        out = '应当通过 "' + e.keyword + ' 关键词校验"'
     }
-    e.message = out;
+    e.message = out
   }
-};
+}

package.json

 {
   "name": "ajv-i18n",
-  "version": "3.6.0",
+  "version": "4.0.0-beta.0",
   "description": "Internationalised error messages for ajv JSON-Schema validator",
@@ -11,15 +11,12 @@ "main": "localize/index.js",
   "scripts": {
-    "build": "node scripts/compile-locales.js",
-    "bundle-all": "npm run browserify && npm run uglify",
-    "bundle-test": "npm run browserify-test && npm run uglify-test",
-    "browserify": "mkdir -p dist/ && browserify -r ./localize/index -o dist/ajv-i18n.bundle.js",
-    "browserify-test": "mkdir -p dist/ && browserify -r ./node_modules/ajv/lib/ajv.js:ajv -r ./localize/index -o dist/ajv-i18n.test.bundle.js",
+    "build": "npm run build:json-schema && npm run build:jtd",
+    "build:json-schema": "node scripts/compile-locales.js '' index",
+    "build:jtd": "node scripts/compile-locales.js '/jtd' jtd",
     "eslint": "eslint messages scripts spec/*.js",
-    "uglify": "uglifyjs ./dist/ajv-i18n.bundle.js -o ./dist/ajv-i18n.min.js -m -c --warn",
-    "uglify-test": "uglifyjs ./dist/ajv-i18n.test.bundle.js -o ./dist/ajv-i18n.test.min.js -m -c --warn",
     "prepublish": "npm run build",
-    "test": "npm run eslint && npm run build && npm run test-cov",
-    "test-spec": "mocha spec/*.spec.js -R spec",
+    "test": "npm run prettier:check && npm run eslint && npm run build && npm run test-cov",
+    "test-spec": "mocha spec/*.spec.js -R dot",
     "test-cov": "nyc npm run test-spec",
-    "test-browser": "npm run bundle-test && scripts/prepare-tests && karma start --single-run --browsers PhantomJS"
+    "prettier:write": "prettier --write \"./**/*.{json,yaml,js,ts}\"",
+    "prettier:check": "prettier --list-different \"./**/*.{json,yaml,js,ts}\""
   },
@@ -44,22 +41,18 @@ "repository": {
   "devDependencies": {
-    "ajv": "^6.0.0",
-    "ajv-keywords": "^3.0.0",
-    "brfs": "^2.0.0",
-    "browserify": "^16.0.0",
+    "@ajv-validator/config": "^0.3.0",
+    "ajv": "^8.0.0-beta.4",
+    "ajv-formats": "^2.0.0-beta.2",
+    "ajv-keywords": "^5.0.0-beta.1",
     "dot": "^1.0.3",
     "eslint": "^7.8.1",
-    "js-beautify": "^1.7.4",
+    "eslint-config-prettier": "^8.1.0",
+    "husky": "^5.1.3",
     "json-schema-test": "^2.0.0",
-    "karma": "^5.0.0",
-    "karma-mocha": "^2.0.0",
-    "karma-phantomjs-launcher": "^1.0.0",
+    "lint-staged": "^10.5.4",
     "mocha": "^8.0.1",
     "nyc": "^15.0.0",
-    "phantomjs-prebuilt": "^2.1.4",
-    "pre-commit": "^1.1.1",
-    "require-globify": "^1.3.0",
-    "uglify-js": "^3.0.10"
+    "prettier": "^2.2.1"
   },
   "peerDependencies": {
-    "ajv": "^6.0.0"
+    "ajv": "^8.0.0-beta.0"
   },
@@ -75,3 +68,12 @@ "nyc": {
     ]
+  },
+  "prettier": "@ajv-validator/config/prettierrc.json",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged && npm test"
+    }
+  },
+  "lint-staged": {
+    "*.{json,yaml,js,ts}": "prettier --write"
   }
 }

README.md

 # ajv-i18n
 
-Internationalised error messages for [Ajv](https://github.com/epoberezkin/ajv) - currently the fastest JSON-Schema validator
+Internationalised error messages for [Ajv](https://github.com/ajv-validator/ajv) - superfast JSON validator for JSON Schema and JSON Type Definition.
 
@@ -10,38 +10,42 @@ [![Build Status](https://travis-ci.org/ajv-validator/ajv-i18n.svg?branch=master)](https://travis-ci.org/ajv-validator/ajv-i18n)
 
-
 ## Supported locales
 
-|locale|language |contributor|draft-04|draft-06<sup>\*</sup>|draft-07<sup>\*\*</sup>|
-|------|:-------:|:---------:|:------:|:------:|:------:|
-|🇬🇧 en|English  | |✓|✓|✓|
-|AR ar|Arabic   |[Mahmoud-Mardeni](https://github.com/Mahmoud-Mardeni)|✓|✓|✓|
-|CA ca|Catalan   |[alexandreec](https://github.com/alexandreec)|✓|✓|✓|
-|🇨🇿 cz|Czech    |[kiskovacs](https://github.com/kiskovacs)<br>[NAM0007](https://github.com/NAM0007)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|
-|🇩🇪 de|German   |[jmtoball](https://github.com/jmtoball)<br>[gflohr](https://github.com/gflohr)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|
-|🇪🇸 es|Spanish  |[jpablom](https://github.com/jpablom)|✓|✓|✓|
-|🇫🇷 fr|French   |[monlouisj](https://github.com/monlouisj)<br>[Telokis](https://github.com/Telokis)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|
-|🇭🇺 hu|Hungarian|[szilveszter9](https://github.com/szilveszter9)|✓|-|-|
-|🇮🇩 id|Indonesian|[Eko Eryanto](https://github.com/ekoeryanto)|✓|✓|✓|
-|🇮🇹 it|Italian  |[jasoniangreen](https://github.com/jasoniangreen)<br>[lucacorti](https://github.com/lucacorti)|✓<br>&nbsp;|<br>✓|<br>✓|
-|🇯🇵 ja|Japanese |[gilgongo](https://github.com/gilgongo)|✓|-|-|
-|🇰🇷 ko|Korean |[MinByeongDon](https://github.com/MinByeongDon)|✓|✓|✓|
-|🇳🇴 nb|Norwegian bokmål|[mtramm](https://github.com/mtramm)|✓|✓|-|
-|🇳🇱 nl|Dutch    |[pimlie](https://github.com/pimlie)<br>[niekvb](https://github.com/niekvb)|✓|✓|✓|
-|🇵🇱 pl|Polish   |[danielzurawski](https://github.com/danielzurawski)|✓|-|-|
-|🇧🇷 pt-BR|Português - Brasil|[marcosrava](https://github.com/marcosrava)<br>[ggondim](https://github.com/ggondim)|✓|✓|✓|
-|🇷🇺 ru|Russian  | |✓|✓|✓|
-|🇸🇰 sk|Slovak   |[kiskovacs](https://github.com/kiskovacs)|✓|✓|-|
-|🇸🇪 sv|Swedish  |[limmen](https://github.com/Limmen)|✓|✓|-|
-|🇹🇭 th|Thai     |[encX](https://github.com/encX)|✓|✓|✓|
-|🇨🇳 zh|Chinese  |[jinzhubaofu](https://github.com/jinzhubaofu)<br>[leuction](https://github.com/leuction)|✓<br>&nbsp;|<br>✓|<br>✓|
-|🇹🇼 zh-TW|Chinese - Taiwan|[minipai](https://github.com/minipai)|✓|✓|✓|
+|locale|language |contributor|draft-04|draft-06<sup>1</sup>|draft-07<sup>2</sup>|draft<br>2019-09<sup>3</sup>|JTD<sup>4</sup>
+|------|:-------:|:---------:|:------:|:------:|:------:|:------:|:------:|
+|🇬🇧 en|English  | |✓|✓|✓|✓|✓|
+|AR ar|Arabic   |[Mahmoud-Mardeni](https://github.com/Mahmoud-Mardeni)|✓|✓|✓|-|-|
+|CA ca|Catalan   |[alexandreec](https://github.com/alexandreec)|✓|✓|✓|-|*|
+|🇨🇿 cs|Czech    |[kiskovacs](https://github.com/kiskovacs)<br>[NAM0007](https://github.com/NAM0007)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|-|*|
+|🇩🇪 de|German   |[jmtoball](https://github.com/jmtoball)<br>[gflohr](https://github.com/gflohr)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|✓<br>&nbsp;|✓<br>&nbsp;|
+|🇪🇸 es|Spanish  |[jpablom](https://github.com/jpablom)|✓|✓|✓|-|*|
+|🇫🇷 fr|French   |[monlouisj](https://github.com/monlouisj)<br>[Telokis](https://github.com/Telokis)|✓<br>&nbsp;|✓<br>&nbsp;|<br>✓|-|*|
+|🇭🇺 hu|Hungarian|[szilveszter9](https://github.com/szilveszter9)|✓|-|-|-|*|
+|🇮🇩 id|Indonesian|[ekoeryanto](https://github.com/ekoeryanto)|✓|✓|✓|-|*|
+|🇮🇹 it|Italian  |[jasoniangreen](https://github.com/jasoniangreen)<br>[lucacorti](https://github.com/lucacorti)|✓<br>&nbsp;|<br>✓|<br>✓|<br>✓|<br>✓|
+|🇯🇵 ja|Japanese |[gilgongo](https://github.com/gilgongo)|✓|-|-|-|*|
+|🇰🇷 ko|Korean |[MinByeongDon](https://github.com/MinByeongDon)|✓|✓|✓|-|*|
+|🇳🇴 nb|Norwegian bokmål|[mtramm](https://github.com/mtramm)|✓|✓|-|-|*|
+|🇳🇱 nl|Dutch    |[pimlie](https://github.com/pimlie)<br>[niekvb](https://github.com/niekvb)|✓|✓|✓|<br>✓|<br>✓|
+|🇵🇱 pl|Polish   |[danielzurawski](https://github.com/danielzurawski)|✓|-|-|-|*|
+|🇧🇷 pt-BR|Português - Brasil|[marcosrava](https://github.com/marcosrava)<br>[ggondim](https://github.com/ggondim)|✓|✓|✓|<br>✓|<br>✓|
+|🇷🇺 ru|Russian  | |✓|✓|✓|✓|✓|
+|🇸🇰 sk|Slovak   |[kiskovacs](https://github.com/kiskovacs)|✓|✓|-|-|*|
+|🇸🇪 sv|Swedish  |[limmen](https://github.com/Limmen)|✓|✓|-|-|*|
+|🇹🇭 th|Thai     |[encX](https://github.com/encX)|✓|✓|✓|✓|✓|
+|🇨🇳 zh|Chinese  |[jinzhubaofu](https://github.com/jinzhubaofu)<br>[leuction](https://github.com/leuction)|✓<br>&nbsp;|<br>✓|<br>✓|<br>✓|<br>✓|
+|🇹🇼 zh-TW|Chinese - Taiwan|[minipai](https://github.com/minipai)|✓|✓|✓|✓|✓|
 
 
-<sup>\*</sup> added boolean schema, keywords `const`, `contains`, `propertyNames`
+<sup>1</sup> added boolean schema, keywords `const`, `contains`, `propertyNames`
 
-<sup>\*\*</sup> added keywords `if`/`then`/`else`
+<sup>2</sup> added keywords `if`/`then`/`else`
 
+<sup>3</sup> added keywords `unevaluatedProperties`, `unevaluatedItems`, `dependentRequired`
+
+<sup>4</sup> JSON Type Definition
+
+\* `discriminator` form messages are not translated
+
 Please contribute locales that you need to use if they are missing or incomplete.
 
-
 ## Install
@@ -55,10 +59,2 @@
 
-Using bower:
-
-```
-bower install ajv-i18n
-cd bower_components/ajv-i18n
-npm install && npm run bundle-all
-```
-
 ## Usage
@@ -69,22 +65,25 @@
 ```javascript
-var Ajv = require('ajv'); // version >= 2.0.0
-var localize = require('ajv-i18n');
+const Ajv = require("ajv") // version >= 8.0.0
+const localize = require("ajv-i18n")
+// or for JSON Type Definition
+// const localize = require("ajv-i18n/localize/jtd")
 
-// option `i18n` is required for this package to work
-var ajv = Ajv({ allErrors: true });
-var validate = ajv.compile(schema);
-var valid = validate(data);
+const ajv = Ajv({allErrors: true, messages: false})
+const validate = ajv.compile(schema)
+const valid = validate(data)
 
 if (!valid) {
-    // ru for Russian
-    localize.ru(validate.errors);
-    // string with all errors and data paths
-    console.log(ajv.errorsText(validate.errors, { separator: '\n' }));
+  // ru for Russian
+  localize.ru(validate.errors)
+  // string with all errors and data paths
+  console.log(ajv.errorsText(validate.errors, {separator: '\n'}))
 }
 ```
 
-To require only necessary locales in browser (with browserify):
+To require only necessary locales (e.g., with browserify):
 
 ```javascript
-var localize_ru = require('ajv-i18n/localize/ru');
+const localize_ru = require('ajv-i18n/localize/ru')
+// or for JSON Type Definition
+// const localize_ru = require('ajv-i18n/localize/ru/jtd')
 ```
@@ -95,11 +94,10 @@
 ```javascript
-var localize = {
-    en: require('ajv-i18n/localize/en'),
-    ru: require('ajv-i18n/localize/ru')
-};
+const localize = {
+  en: require('ajv-i18n/localize/en'),
+  ru: require('ajv-i18n/localize/ru'),
+}
 ```
 
-See [Ajv docs](https://github.com/epoberezkin/ajv) for more information.
+See [Ajv docs](https://github.com/ajv-validator/ajv) for more information.
 
-
 ## Tests
@@ -113,10 +111,8 @@
 
-
 ## Contributing
 
-Functions that localize error messages are generated using doT templates in [messages](https://github.com/epoberezkin/ajv-i18n/tree/master/messages/index.js) and [localize.jst](https://github.com/epoberezkin/ajv-i18n/tree/master/localize/localize.jst) template. Templates are precompiled so doT is not a run-time dependency.
+Functions that localize error messages are generated using doT template [localize.jst](https://github.com/ajv-validator/ajv-i18n/tree/master/localize/localize.jst), [JSON Schema messages](https://github.com/ajv-validator/ajv-i18n/tree/master/messages/index.js) and [JSON Type Definition messages](https://github.com/ajv-validator/ajv-i18n/tree/master/messages/jtd.js). Templates are pre-compiled, so doT is not a run-time dependency.
 
-`npm run build` - compiles functions to [localize](https://github.com/epoberezkin/ajv/tree/master/localize) folder.
+`npm run build` - compiles functions to [localize](https://github.com/ajv-validator/ajv/tree/master/localize) folder.
 
-
 ## Contributors of locales
@@ -152,3 +148,2 @@
 
-
 ## Enterprise support
@@ -158,3 +153,2 @@
 
-
 ## Security contact
@@ -166,5 +160,4 @@
 
-
 ## License
 
-[MIT](https://github.com/epoberezkin/ajv-i18n/blob/master/LICENSE)
+[MIT](https://github.com/ajv-validator/ajv-i18n/blob/master/LICENSE)

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

170140

increased by26.13%

Dev dependency count

13

decreased by-23.53%

Number of package files

100

increased by257.14%

Lines of code

5349

increased by40.84%

Worsened metrics

Number of low quality alerts

1

increased byInfinity%

Number of lines in readme file

156

decreased by-4.29%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes