@hyperjump/json-schema 1.7.3 → 1.9.0

package/lib/keywords/enum.js

@@ -1,4 +1,4 @@
-import jsonStringify from "fastest-stable-stringify";
+import jsonStringify from "json-stringify-deterministic";
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
@@ -13,6 +13,9 @@ const compile = (schema) => pipe(
   asyncCollectArray
 );
 
-const interpret = (enum_, instance) => enum_.some((enumValue) => jsonStringify(Instance.value(instance)) === enumValue);
+const interpret = (enum_, instance) => {
+  const instanceValue = jsonStringify(Instance.value(instance));
+  return enum_.some((enumValue) => instanceValue === enumValue);
+};
 
 export default { id, compile, interpret };

package/lib/keywords/examples.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/examples", ...metaData };
+const id = "https://json-schema.org/keyword/examples";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (examples, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, examples);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/format.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/format", ...metaData };
+const id = "https://json-schema.org/keyword/format";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (format, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, format);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/items.js

@@ -1,4 +1,4 @@
-import { pipe, drop, every } from "@hyperjump/pact";
+import { drop } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { getKeywordName, Validation } from "../experimental.js";
@@ -19,11 +19,14 @@ const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors,
     return true;
   }
 
-  return pipe(
-    Instance.iter(instance),
-    drop(numberOfPrefixItems),
-    every((item) => Validation.interpret(items, item, ast, dynamicAnchors, quiet))
-  );
+  let isValid = true;
+  for (const item of drop(numberOfPrefixItems, Instance.iter(instance))) {
+    if (!Validation.interpret(items, item, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {

package/lib/keywords/maxContains.js

@@ -1,4 +1,8 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
 
 
-export default { id: "https://json-schema.org/keyword/maxContains", ...metaData };
+const id = "https://json-schema.org/keyword/maxContains";
+const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+
+export default { id, compile, interpret };

package/lib/keywords/maxItems.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/maxItems";
 
 const compile = (schema) => Browser.value(schema);
-const interpret = (maxItems, instance) => Instance.typeOf(instance) !== "array" || Instance.length(instance) <= maxItems;
+const interpret = (maxItems, instance) => {
+  return Instance.typeOf(instance) !== "array" || Instance.length(instance) <= maxItems;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/maxLength.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/maxLength";
 
 const compile = (schema) => Browser.value(schema);
-const interpret = (maxLength, instance) => Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length <= maxLength;
+const interpret = (maxLength, instance) => {
+  return Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length <= maxLength;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/minContains.js

@@ -1,4 +1,8 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
 
 
-export default { id: "https://json-schema.org/keyword/minContains", ...metaData };
+const id = "https://json-schema.org/keyword/minContains";
+const compile = (schema) => Browser.value(schema);
+const interpret = () => true;
+
+export default { id, compile, interpret };

package/lib/keywords/minItems.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/minItems";
 
 const compile = (schema) => Browser.value(schema);
-const interpret = (minItems, instance) => Instance.typeOf(instance) !== "array" || Instance.length(instance) >= minItems;
+const interpret = (minItems, instance) => {
+  return Instance.typeOf(instance) !== "array" || Instance.length(instance) >= minItems;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/minLength.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/minLength";
 
 const compile = (schema) => Browser.value(schema);
-const interpret = (minLength, instance) => Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length >= minLength;
+const interpret = (minLength, instance) => {
+  return Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length >= minLength;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/oneOf.js

@@ -17,10 +17,6 @@ const interpret = (oneOf, instance, ast, dynamicAnchors, quiet) => {
     if (Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet)) {
       validCount++;
     }
-
-    if (validCount > 1) {
-      break;
-    }
   }
 
   return validCount === 1;

package/lib/keywords/pattern.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/pattern";
 
 const compile = (schema) => new RegExp(Browser.value(schema), "u");
-const interpret = (pattern, instance) => Instance.typeOf(instance) !== "string" || pattern.test(Instance.value(instance));
+const interpret = (pattern, instance) => {
+  return Instance.typeOf(instance) !== "string" || pattern.test(Instance.value(instance));
+};
 
 export default { id, compile, interpret };

package/lib/keywords/patternProperties.js

@@ -1,4 +1,4 @@
-import { pipe, asyncMap, asyncCollectArray, filter, every } from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { Validation } from "../experimental.js";
@@ -16,13 +16,21 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "object" || patternProperties.every(([pattern, schemaUrl]) => {
-    return pipe(
-      Instance.entries(instance),
-      filter(([propertyName]) => pattern.test(propertyName)),
-      every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors, quiet))
-    );
-  });
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [pattern, schemaUri] of patternProperties) {
+    for (const [propertyNameNode, propertyValue] of Instance.entries(instance)) {
+      const propertyName = Instance.value(propertyNameNode);
+      if (pattern.test(propertyName) && !Validation.interpret(schemaUri, propertyValue, ast, dynamicAnchors, quiet)) {
+        isValid = false;
+      }
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnchors) => {
@@ -32,7 +40,8 @@ const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnc
 
   const evaluatedPropertyNames = new Set();
   for (const [pattern, propertySchema] of patternProperties) {
-    for (const [propertyName, property] of Instance.entries(instance)) {
+    for (const [propertyNameNode, property] of Instance.entries(instance)) {
+      const propertyName = Instance.value(propertyNameNode);
       if (pattern.test(propertyName)) {
         if (!Validation.interpret(propertySchema, property, ast, dynamicAnchors, true)) {
           return false;

package/lib/keywords/prefixItems.js

@@ -1,4 +1,4 @@
-import { pipe, asyncMap, asyncCollectArray, every, zip, take } from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray, zip } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { Validation } from "../experimental.js";
@@ -13,11 +13,26 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "array" || pipe(
-    zip(prefixItems, Instance.iter(instance)),
-    take(Instance.length(instance)),
-    every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))
-  );
+  if (Instance.typeOf(instance) !== "array") {
+    return true;
+  }
+
+  let isValid = true;
+  let index = 0;
+  const instanceLength = Instance.length(instance);
+  for (const [schemaUri, item] of zip(prefixItems, Instance.iter(instance))) {
+    if (index >= instanceLength) {
+      break;
+    }
+
+    if (!Validation.interpret(schemaUri, item, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+
+    index++;
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {

package/lib/keywords/properties.js

@@ -1,4 +1,4 @@
-import { pipe, asyncMap, asyncCollectObject, filter, every } from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectObject } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { Validation } from "../experimental.js";
@@ -13,11 +13,19 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "object" || pipe(
-    Instance.entries(instance),
-    filter(([propertyName]) => propertyName in properties),
-    every(([propertyName, property]) => Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, quiet))
-  );
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [propertyNameNode, property] of Instance.entries(instance)) {
+    const propertyName = Instance.value(propertyNameNode);
+    if (propertyName in properties && !Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
@@ -26,7 +34,8 @@ const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) =
   }
 
   const evaluatedPropertyNames = new Set();
-  for (const [propertyName, property] of Instance.entries(instance)) {
+  for (const [propertyNameNode, property] of Instance.entries(instance)) {
+    const propertyName = Instance.value(propertyNameNode);
     if (propertyName in properties) {
       if (!Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, true)) {
         return false;

package/lib/keywords/propertyDependencies.js

@@ -21,12 +21,24 @@ const compile = (schema, ast) => {
 };
 
 const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "object" || Object.entries(propertyDependencies).every(([propertyName, valueMappings]) => {
-    const propertyValue = Instance.value(instance)[propertyName];
-    return !Instance.has(propertyName, instance)
-      || !(propertyValue in valueMappings)
-      || Validation.interpret(valueMappings[propertyValue], instance, ast, dynamicAnchors, quiet);
-  });
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  const instanceValue = Instance.value(instance);
+  for (const [propertyName, valueMappings] of Object.entries(propertyDependencies)) {
+    const propertyValue = instanceValue[propertyName];
+    if (
+      Instance.has(propertyName, instance)
+      && propertyValue in valueMappings
+      && !Validation.interpret(valueMappings[propertyValue], instance, ast, dynamicAnchors, quiet)
+    ) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedProperties = (propertyDependencies, instance, ast, dynamicAnchors) => {

package/lib/keywords/propertyNames.js

@@ -1,6 +1,5 @@
-import { every } from "@hyperjump/pact";
-import * as Instance from "../instance.js";
 import { Validation } from "../experimental.js";
+import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/propertyNames";
@@ -8,9 +7,18 @@ const id = "https://json-schema.org/keyword/propertyNames";
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
-  return Instance.typeOf(instance) !== "object" || every((key) => {
-    return Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors, true);
-  }, Instance.keys(instance));
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  for (const key of Instance.keys(instance)) {
+    if (!Validation.interpret(propertyNames, key, ast, dynamicAnchors, true)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 export default { id, compile, interpret };

package/lib/keywords/readOnly.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/readOnly", ...metaData };
+const id = "https://json-schema.org/keyword/readOnly";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (readOnly, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, readOnly);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/title.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/title", ...metaData };
+const id = "https://json-schema.org/keyword/title";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (title, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, title);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/unevaluatedItems.js

@@ -1,6 +1,6 @@
-import { pipe, filter, every, zip, range } from "@hyperjump/pact";
-import { canonicalUri } from "../schema.js";
+import { zip, range } from "@hyperjump/pact";
 import * as Instance from "../instance.js";
+import { canonicalUri } from "../schema.js";
 import { Validation } from "../experimental.js";
 
 
@@ -16,11 +16,18 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors,
   }
 
   const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
-  return itemIndexes === false || pipe(
-    zip(Instance.iter(instance), range(0)),
-    filter(([, index]) => !itemIndexes.has(index)),
-    every(([item]) => Validation.interpret(unevaluatedItems, item, ast, dynamicAnchors, quiet))
-  );
+  if (itemIndexes === false) {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [item, index] of zip(Instance.iter(instance), range(0))) {
+    if (!itemIndexes.has(index) && !Validation.interpret(unevaluatedItems, item, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {

package/lib/keywords/unevaluatedProperties.js

@@ -1,6 +1,5 @@
-import { pipe, filter, every } from "@hyperjump/pact";
-import * as Instance from "../instance.js";
 import { Validation, canonicalUri } from "../experimental.js";
+import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedProperties";
@@ -15,12 +14,19 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
   }
 
   const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+  if (evaluatedPropertyNames === false) {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [propertyNameNode, property] of Instance.entries(instance)) {
+    const propertyName = Instance.value(propertyNameNode);
+    if (!evaluatedPropertyNames.has(propertyName) && !Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
 
-  return !evaluatedPropertyNames || pipe(
-    Instance.entries(instance),
-    filter(([propertyName]) => !evaluatedPropertyNames.has(propertyName)),
-    every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet))
-  );
+  return isValid;
 };
 
 const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
@@ -34,7 +40,8 @@ const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance
     return false;
   }
 
-  for (const [propertyName, property] of Instance.entries(instance)) {
+  for (const [propertyNameNode, property] of Instance.entries(instance)) {
+    const propertyName = Instance.value(propertyNameNode);
     if (!evaluatedPropertyNames.has(propertyName)) {
       if (!Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, true)) {
         return false;

package/lib/keywords/uniqueItems.js

@@ -1,4 +1,4 @@
-import jsonStringify from "fastest-stable-stringify";
+import jsonStringify from "json-stringify-deterministic";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 

package/lib/keywords/unknown.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/unknown", ...metaData };
+const id = "https://json-schema.org/keyword/unknown";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (value, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, value);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/validation.js

@@ -1,8 +1,7 @@
 import { value, entries } from "@hyperjump/browser";
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import { append as pointerAppend } from "@hyperjump/json-pointer";
-import { publishAsync, publish } from "../pubsub.js";
-import * as Instance from "../instance.js";
+import { publishAsync } from "../pubsub.js";
 import { toAbsoluteUri } from "../common.js";
 import { canonicalUri, getKeyword, getKeywordByName } from "../experimental.js";
 
@@ -47,31 +46,29 @@ const compile = async (schema, ast) => {
 const interpret = (url, instance, ast, dynamicAnchors, quiet = false) => {
   dynamicAnchors = { ...ast.metaData[toAbsoluteUri(url)].dynamicAnchors, ...dynamicAnchors };
 
-  !quiet && publish("result.start");
-  const isValid = typeof ast[url] === "boolean" ? ast[url] : ast[url].every(([keywordId, schemaUrl, keywordValue]) => {
-    !quiet && publish("result.start");
-    const isValid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors, quiet);
-
-    !quiet && publish("result", {
-      keyword: keywordId,
-      absoluteKeywordLocation: schemaUrl,
-      instanceLocation: Instance.uri(instance),
-      valid: isValid,
-      ast: keywordValue
-    });
-    !quiet && publish("result.end");
-    return isValid;
-  });
-
-  !quiet && publish("result", {
-    keyword: id,
-    absoluteKeywordLocation: url,
-    instanceLocation: Instance.uri(instance),
-    valid: isValid,
-    ast: url
-  });
-  !quiet && publish("result.end");
-  return isValid;
+  let isSchemaValid = true;
+  if (typeof ast[url] === "boolean") {
+    isSchemaValid = ast[url];
+  } else {
+    for (const [keywordId, schemaUrl, keywordValue] of ast[url]) {
+      instance.valid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors, quiet, url);
+      if (!instance.valid) {
+        if (!quiet) {
+          instance.errors[schemaUrl] = keywordId;
+        }
+        isSchemaValid = false;
+      }
+    }
+  }
+
+  if (!isSchemaValid) {
+    if (!quiet) {
+      instance.errors[url] = id;
+    }
+  }
+
+  instance.valid = isSchemaValid;
+  return isSchemaValid;
 };
 
 const emptyPropertyNames = new Set();

package/lib/keywords/writeOnly.js

@@ -1,4 +1,14 @@
-import metaData from "./meta-data.js";
+import * as Browser from "@hyperjump/browser";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
-export default { id: "https://json-schema.org/keyword/writeOnly", ...metaData };
+const id = "https://json-schema.org/keyword/writeOnly";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (writeOnly, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, writeOnly);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords.js

@@ -81,3 +81,8 @@ export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false) =>
       }
     });
 };
+
+export const unloadDialect = (dialectId) => {
+  delete _allowUnknownKeywords[dialectId];
+  delete _dialects[dialectId];
+};

package/lib/output.js

@@ -0,0 +1,43 @@
+import { allNodes } from "./instance.js";
+
+
+const outputFormats = {};
+
+export const toOutputFormat = (node, outputFormat) => {
+  if (outputFormat in outputFormats) {
+    return outputFormats[outputFormat](node);
+  } else {
+    throw Error(`The '${outputFormat}' error format is not supported`);
+  }
+};
+
+outputFormats.FLAG = (instance) => {
+  return { valid: instance.valid };
+};
+
+outputFormats.BASIC = (instance) => {
+  const output = {
+    valid: instance.valid
+  };
+
+  if (!instance.valid) {
+    output.errors = [];
+
+    for (const child of allNodes(instance)) {
+      for (const [absoluteKeywordLocation, keyword] of Object.entries(child.errors).reverse()) {
+        if (!child.valid) {
+          output.errors.unshift({
+            keyword,
+            absoluteKeywordLocation,
+            instanceLocation: child.uri(),
+            valid: child.valid
+          });
+        }
+      }
+    }
+
+    output.errors.pop();
+  }
+
+  return output;
+};