@hyperjump/json-schema 1.7.3 → 1.9.0

package/lib/core.js

@@ -1,6 +1,6 @@
 import curry from "just-curry-it";
 import { resolveIri, toAbsoluteIri } from "@hyperjump/uri";
-import { subscribe, unsubscribe } from "./pubsub.js";
+import { subscribe } from "./pubsub.js";
 import {
   setMetaSchemaOutputFormat,
   getShouldValidateSchema,
@@ -11,15 +11,16 @@ import { InvalidSchemaError } from "./invalid-schema-error.js";
 import { getSchema, registerSchema, unregisterSchema as schemaUnregister } from "./schema.js";
 import { getKeywordName } from "./keywords.js";
 import Validation from "./keywords/validation.js";
+import { toOutputFormat } from "./output.js";
 
 
-export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
+export const FLAG = "FLAG", BASIC = "BASIC";
 setMetaSchemaOutputFormat(FLAG);
 
 export const validate = async (url, value = undefined, outputFormat = undefined) => {
   const schema = await getSchema(url);
   const compiled = await compile(schema);
-  const interpretAst = (value, outputFormat) => interpret(compiled, Instance.cons(value), outputFormat);
+  const interpretAst = (value, outputFormat) => interpret(compiled, Instance.fromJs(value), outputFormat);
 
   return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 };
@@ -30,54 +31,11 @@ export const compile = async (schema) => {
   return { ast, schemaUri };
 };
 
-export const interpret = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
-  if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
-    throw Error(`The '${outputFormat}' error format is not supported`);
-  }
-
-  const output = [];
-  const subscriptionToken = subscribe("result", outputHandler(outputFormat, output));
-  try {
-    Validation.interpret(schemaUri, value, ast, {});
-  } finally {
-    unsubscribe("result", subscriptionToken);
-  }
-
-  return output[0];
+export const interpret = curry(({ ast, schemaUri }, instance, outputFormat = FLAG) => {
+  Validation.interpret(schemaUri, instance, ast, {});
+  return toOutputFormat(instance, outputFormat);
 });
 
-const outputHandler = (outputFormat, output) => {
-  const resultStack = [];
-
-  return (message, keywordResult) => {
-    if (message === "result") {
-      const { keyword, absoluteKeywordLocation, instanceLocation, valid } = keywordResult;
-      const result = { keyword, absoluteKeywordLocation, instanceLocation, valid, errors: [] };
-      resultStack.push(result);
-    } else if (message === "result.start") {
-      resultStack.push(message);
-    } else if (message === "result.end") {
-      const result = resultStack.pop();
-      while (resultStack[resultStack.length - 1] !== "result.start") {
-        const topResult = resultStack.pop();
-
-        const errors = [topResult];
-        if (outputFormat === BASIC) {
-          errors.push(...topResult.errors);
-          delete topResult.errors;
-        }
-
-        if (outputFormat === VERBOSE || (outputFormat !== FLAG && !topResult.valid)) {
-          result.errors.unshift(...errors);
-        }
-      }
-      resultStack[resultStack.length - 1] = result;
-
-      output[0] = result;
-    }
-  };
-};
-
 const metaValidators = {};
 subscribe("validate.metaValidate", async (_message, schema) => {
   if (getShouldValidateSchema() && !schema.document.validated) {
@@ -91,7 +49,7 @@ subscribe("validate.metaValidate", async (_message, schema) => {
     }
 
     // Interpret
-    const schemaInstance = Instance.cons(schema.document.root, schema.document.baseUri);
+    const schemaInstance = Instance.fromJs(schema.document.root, schema.document.baseUri);
     const metaResults = metaValidators[schema.document.dialectId](schemaInstance, getMetaSchemaOutputFormat());
     if (!metaResults.valid) {
       throw new InvalidSchemaError(metaResults);

package/lib/experimental.d.ts

@@ -1,10 +1,10 @@
 import type { Browser, Document } from "@hyperjump/browser";
 import type { Validator, OutputUnit, OutputFormat, SchemaObject } from "./index.js";
-import type { JsonDocument } from "./instance.js";
+import type { JsonNode } from "./instance.js";
 
 
 // Compile/interpret
-export const compile: (url: string) => Promise<CompiledSchema>;
+export const compile: (schema: Browser<SchemaDocument>) => Promise<CompiledSchema>;
 export const interpret: (
   (compiledSchema: CompiledSchema, value: unknown, outputFormat?: OutputFormat) => OutputUnit
 ) & (
@@ -32,8 +32,6 @@ type Anchors = Record<string, string>;
 
 // Output Formats
 export const BASIC: "BASIC";
-export const DETAILED: "DETAILED";
-export const VERBOSE: "VERBOSE";
 
 // Schema
 export const getSchema: (uri: string, browser?: Browser) => Promise<Browser<SchemaDocument>>;
@@ -63,14 +61,15 @@ export const getKeywordByName: <A>(keywordName: string, dialectId: string) => Ke
 export const getKeywordId: (keywordName: string, dialectId: string) => string;
 export const defineVocabulary: (id: string, keywords: { [keyword: string]: string }) => void;
 export const loadDialect: (dialectId: string, dialect: { [vocabularyId: string]: boolean }, allowUnknownKeywords?: boolean) => void;
+export const unloadDialect: (dialectId: string) => void;
 export const hasDialect: (dialectId: string) => boolean;
 
 export type Keyword<A> = {
   id: string;
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
-  interpret: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors) => boolean;
-  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<string> | false;
-  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<number> | false;
+  interpret: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, quiet: boolean, schemaLocation: string) => boolean;
+  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<string> | false;
+  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<number> | false;
   collectExternalIds?: (visited: Set<string>, parentSchema: Browser<SchemaDocument>, schema: Browser<SchemaDocument>) => Promise<Set<string>>;
   annotation?: <B>(compiledKeywordValue: A) => B;
 };

package/lib/experimental.js

@@ -1,4 +1,8 @@
-export { compile, interpret, BASIC, DETAILED, VERBOSE } from "./core.js";
-export { getKeyword, getKeywordByName, addKeyword, defineVocabulary, getKeywordName, getKeywordId, loadDialect, hasDialect } from "./keywords.js";
+export { compile, interpret, BASIC } from "./core.js";
+export {
+  addKeyword, getKeyword, getKeywordByName, getKeywordName, getKeywordId,
+  defineVocabulary,
+  loadDialect, unloadDialect, hasDialect
+} from "./keywords.js";
 export { getSchema, toSchema, canonicalUri, buildSchemaDocument } from "./schema.js";
 export { default as Validation } from "./keywords/validation.js";

package/lib/index.d.ts

@@ -1,3 +1,6 @@
+import type { Json } from "@hyperjump/json-pointer";
+
+
 export type SchemaFragment = string | number | boolean | null | SchemaObject | SchemaFragment[];
 export type SchemaObject = {
   [keyword: string]: SchemaFragment;
@@ -12,12 +15,12 @@ export const unregisterSchema: (retrievalUri: string) => void;
 export const addSchema: typeof registerSchema;
 
 export const validate: (
-  (url: string, value: unknown, outputFormat?: OutputFormat) => Promise<OutputUnit>
+  (url: string, value: Json, outputFormat?: OutputFormat) => Promise<OutputUnit>
 ) & (
   (url: string) => Promise<Validator>
 );
 
-export type Validator = (value: unknown, outputFormat?: OutputFormat) => OutputUnit;
+export type Validator = (value: Json, outputFormat?: OutputFormat) => OutputUnit;
 
 export type OutputUnit = {
   keyword: string;

package/lib/instance.d.ts

@@ -1,29 +1,30 @@
-import type { JsonType } from "./common.js";
-import type { Json, JsonObject } from "@hyperjump/json-pointer";
+import type { Json } from "@hyperjump/json-pointer";
 
 
-export const nil: JsonDocument<undefined>;
-export const cons: (instance: Json, id?: string) => JsonDocument;
-export const get: (url: string, context?: JsonDocument) => JsonDocument;
-export const uri: (doc: JsonDocument) => string;
-export const value: <A extends Json>(doc: JsonDocument<A>) => A;
-export const has: (key: string, doc: JsonDocument<JsonObject>) => boolean;
-export const typeOf: (doc: JsonDocument) => JsonType;
-export const step: (key: string, doc: JsonDocument<JsonObject | Json[]>) => JsonDocument<typeof doc.value>;
-export const iter: (doc: JsonDocument<JsonObject>) => Generator<JsonDocument>;
-export const keys: (doc: JsonDocument<JsonObject>) => Generator<string>;
-export const values: (doc: JsonDocument<JsonObject>) => Generator<JsonDocument>;
-export const entries: (doc: JsonDocument<JsonObject>) => Generator<[string, JsonDocument]>;
-export const length: (doc: JsonDocument<Json[] | string>) => number;
+export const fromJs: (value: Json, uri?: string) => JsonNode;
 
-type MapFn<A> = (element: JsonDocument, index: number) => A;
-type ForEachFn = (element: JsonDocument, index: number) => void;
-type FilterFn = (element: JsonDocument, index: number) => boolean;
-type ReduceFn<A> = (accumulator: A, currentValue: JsonDocument, index: number) => A;
+export const get: (url: string, context: JsonNode) => JsonNode | undefined;
+export const uri: (node: JsonNode) => string;
+export const value: <A>(node: JsonNode) => A;
+export const has: (key: string, node: JsonNode) => boolean;
+export const typeOf: (node: JsonNode) => JsonType;
+export const step: (key: string, node: JsonNode) => JsonNode;
+export const iter: (node: JsonNode) => Generator<JsonNode>;
+export const keys: (node: JsonNode) => Generator<JsonNode>;
+export const values: (node: JsonNode) => Generator<JsonNode>;
+export const entries: (node: JsonNode) => Generator<[JsonNode, JsonNode]>;
+export const length: (node: JsonNode) => number;
 
-export type JsonDocument<A extends Json | undefined = Json> = {
-  id: string;
+export const allNodes: (node) => Generator<JsonNode>;
+
+export type JsonNode = {
+  baseUri: string;
   pointer: string;
-  instance: Json;
-  value: A;
+  type: JsonNodeType;
+  children: JsonNode[];
+  parent: JsonNode;
+  root: JsonNode;
+  valid: boolean;
 };
+
+type JsonNodeType = "object" | "array" | "string" | "number" | "boolean" | "null" | "property";

package/lib/instance.js

@@ -1,63 +1,158 @@
-import { append as pointerAppend, get as pointerGet } from "@hyperjump/json-pointer";
+import * as JsonPointer from "@hyperjump/json-pointer";
+import { reduce } from "@hyperjump/pact";
 import { toAbsoluteIri } from "@hyperjump/uri";
-import { jsonTypeOf, uriFragment } from "./common.js";
 import { Reference } from "@hyperjump/browser/jref";
+import { toAbsoluteUri, uriFragment } from "./common.js";
 
 
-export const nil = { id: undefined, pointer: "", instance: undefined, value: undefined };
-export const cons = (instance, id = undefined) => ({
-  ...nil,
-  id: id ? toAbsoluteIri(id) : "",
-  instance,
-  value: instance
-});
+export const fromJs = (value, uri = "", pointer = "", parent = undefined) => {
+  const jsType = typeof value;
 
-export const get = (url, instance = nil) => {
-  if (!url.startsWith("#")) {
-    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+  switch (jsType) {
+    case "number":
+    case "string":
+    case "boolean":
+      return cons(uri, pointer, value, jsType, [], parent);
+    case "object":
+      if (value === null) {
+        return cons(uri, pointer, value, "null", [], parent);
+      } else if (Array.isArray(value)) {
+        const arrayNode = cons(uri, pointer, value, "array", [], parent);
+        arrayNode.children = value.map((item, index) => {
+          return fromJs(item, uri, JsonPointer.append(index, pointer), arrayNode);
+        });
+        return arrayNode;
+      } else if (Object.getPrototypeOf(value) === Object.prototype) {
+        const objectNode = cons(uri, pointer, value, "object", [], parent);
+        objectNode.children = Object.entries(value).map((entry) => {
+          const propertyPointer = JsonPointer.append(entry[0], pointer);
+          const propertyNode = cons(uri, propertyPointer, undefined, "property", [], objectNode);
+          propertyNode.children = entry.map((property) => fromJs(property, uri, propertyPointer, propertyNode));
+          return propertyNode;
+        });
+        return objectNode;
+      } else if (value instanceof Reference) {
+        return fromJs(value.toJSON(), uri, pointer, parent);
+      }
+    default:
+      const type = jsType === "object" ? Object.getPrototypeOf(value).constructor.name || "anonymous" : jsType;
+      throw Error(`Not a JSON compatible type: ${type}`);
   }
+};
 
-  const pointer = uriFragment(url);
-  return {
-    ...instance,
+const cons = (baseUri, pointer, value, type, children, parent) => {
+  const node = {
+    baseUri: baseUri ? toAbsoluteIri(baseUri) : "",
     pointer: pointer,
-    value: pointerGet(pointer, instance.instance)
+    value: value,
+    type: type,
+    children: children,
+    parent: parent,
+    valid: true,
+    errors: {},
+    annotations: {}
   };
+  node.root = parent?.root ?? node;
+
+  return node;
+};
+
+export const get = (uri, instance) => {
+  const schemaId = toAbsoluteUri(uri);
+  if (schemaId !== instance.baseUri && schemaId !== "") {
+    throw Error(`Reference '${uri}' is not local to '${instance.baseUri}'`);
+  }
+
+  const pointer = uriFragment(uri);
+  return reduce((node, segment) => {
+    segment = segment === "-" && typeOf(node) === "array" ? length(node) : segment;
+    return step(segment, node);
+  }, instance.root, JsonPointer.pointerSegments(pointer));
+};
+
+export const uri = (node) => `${node.baseUri}#${encodeURI(node.pointer)}`;
+export const value = (node) => node.value;
+export const typeOf = (node) => node.type;
+export const has = (key, node) => key in node.value;
+
+export const step = (key, node) => {
+  if (node.type !== "object" && node.type !== "array") {
+    return;
+  }
+
+  switch (node.type) {
+    case "object":
+      const property = node.children.find((propertyNode) => {
+        return value(propertyNode.children[0]) === key;
+      });
+      return property?.children[1];
+    case "array":
+      const index = parseInt(key, 10);
+      return node.children[index];
+    default:
+      return;
+  }
 };
 
-export const uri = (doc) => `${doc.id || ""}#${encodeURI(doc.pointer)}`;
-export const value = (doc) => doc.value instanceof Reference ? doc.value.toJSON() : doc.value;
-export const has = (key, doc) => key in value(doc);
-export const typeOf = (doc) => jsonTypeOf(value(doc));
+export const iter = function* (node) {
+  if (node.type !== "array") {
+    return;
+  }
+
+  yield* node.children;
+};
 
-export const step = (key, doc) => ({
-  ...doc,
-  pointer: pointerAppend(key, doc.pointer),
-  value: value(doc)[key]
-});
+export const keys = function* (node) {
+  if (node.type !== "object") {
+    return;
+  }
 
-export const iter = function* (doc) {
-  for (let index = 0; index < value(doc).length; index++) {
-    yield step(index, doc);
+  for (const property of node.children) {
+    yield property.children[0];
   }
 };
 
-export const keys = function* (doc) {
-  for (const key in value(doc)) {
-    yield key;
+export const values = function* (node) {
+  if (node.type !== "object") {
+    return;
+  }
+
+  for (const property of node.children) {
+    yield property.children[1];
   }
 };
 
-export const values = function* (doc) {
-  for (const key in value(doc)) {
-    yield step(key, doc);
+export const entries = function* (node) {
+  if (node.type !== "object") {
+    return;
+  }
+
+  for (const property of node.children) {
+    yield property.children;
   }
 };
 
-export const entries = function* (doc) {
-  for (const key in value(doc)) {
-    yield [key, step(key, doc)];
+export const length = (node) => {
+  if (node.type !== "array") {
+    return;
   }
+
+  return node.children.length;
 };
 
-export const length = (doc) => value(doc).length;
+export const allNodes = function* (node) {
+  yield node;
+
+  switch (typeOf(node)) {
+    case "object":
+      for (const child of values(node)) {
+        yield* allNodes(child);
+      }
+      break;
+    case "array":
+      for (const child of iter(node)) {
+        yield* allNodes(child);
+      }
+      break;
+  }
+};

package/lib/keywords/additionalProperties.js

@@ -1,4 +1,4 @@
-import { concat, join, empty, map, filter, every, pipe } from "@hyperjump/pact";
+import { concat, join, empty, map, pipe } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { getKeywordName, Validation } from "../experimental.js";
@@ -36,11 +36,15 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dyn
     return true;
   }
 
-  return pipe(
-    Instance.entries(instance),
-    filter(([propertyName]) => !isDefinedProperty.test(propertyName)),
-    every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet))
-  );
+  let isValid = true;
+  for (const [propertyNameNode, property] of Instance.entries(instance)) {
+    const propertyName = Instance.value(propertyNameNode);
+    if (!isDefinedProperty.test(propertyName) && !Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors) => {
@@ -49,7 +53,8 @@ const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], i
   }
 
   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 (!isDefinedProperty.test(propertyName)) {
       if (!Validation.interpret(additionalProperties, property, ast, dynamicAnchors, true)) {
         return false;

package/lib/keywords/allOf.js

@@ -12,7 +12,13 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (allOf, instance, ast, dynamicAnchors, quiet) => {
-  return allOf.every((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet));
+  let isValid = true;
+  for (const schemaUri of allOf) {
+    if (!Validation.interpret(schemaUri, instance, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+  return isValid;
 };
 
 const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {

package/lib/keywords/comment.js

@@ -1,4 +1,5 @@
-import metaData from "./meta-data.js";
+const id = "https://json-schema.org/keyword/comment";
+const compile = () => undefined;
+const interpret = () => true;
 
-
-export default { id: "https://json-schema.org/keyword/comment", ...metaData };
+export default { id, compile, interpret };

package/lib/keywords/const.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/contentEncoding.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/contentEncoding", ...metaData };
+const id = "https://json-schema.org/keyword/contentEncoding";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (contentEncoding, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, contentEncoding);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/contentMediaType.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/contentMediaType", ...metaData };
+const id = "https://json-schema.org/keyword/contentMediaType";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (contentMediaType, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, contentMediaType);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/contentSchema.js

@@ -1,9 +1,14 @@
-import * as Schema from "../schema.js";
+import { canonicalUri } from "../schema.js";
+import * as Instance from "../../annotations/annotated-instance.js";
 
 
 const id = "https://json-schema.org/keyword/contentSchema";
 
-const compile = (contentSchema) => Schema.canonicalUri(contentSchema);
-const interpret = () => true;
+const compile = (contentSchema) => canonicalUri(contentSchema);
+
+const interpret = (contentSchema, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, contentSchema);
+  return true;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/default.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/default", ...metaData };
+const id = "https://json-schema.org/keyword/default";
+
+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/dependentRequired.js

@@ -12,9 +12,18 @@ const compile = (schema) => pipe(
 );
 
 const interpret = (dependentRequired, instance) => {
-  return Instance.typeOf(instance) !== "object" || dependentRequired.every(([propertyName, required]) => {
-    return !Instance.has(propertyName, instance) || required.every((key) => Instance.has(key, instance));
-  });
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [propertyName, required] of dependentRequired) {
+    if (Instance.has(propertyName, instance) && !required.every((key) => Instance.has(key, instance))) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 export default { id, compile, interpret };

package/lib/keywords/dependentSchemas.js

@@ -13,9 +13,18 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (dependentSchemas, instance, ast, dynamicAnchors, quiet) => {
-  return Instance.typeOf(instance) !== "object" || dependentSchemas.every(([propertyName, dependentSchema]) => {
-    return !Instance.has(propertyName, instance) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
-  });
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
+
+  let isValid = true;
+  for (const [propertyName, dependentSchema] of dependentSchemas) {
+    if (Instance.has(propertyName, instance) && !Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet)) {
+      isValid = false;
+    }
+  }
+
+  return isValid;
 };
 
 const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {

package/lib/keywords/deprecated.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/deprecated", ...metaData };
+const id = "https://json-schema.org/keyword/deprecated";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (deprecated, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, deprecated);
+  return true;
+};
+
+export default { id, compile, interpret };

package/lib/keywords/description.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/description", ...metaData };
+const id = "https://json-schema.org/keyword/description";
+
+const compile = (schema) => Browser.value(schema);
+
+const interpret = (description, instance, _ast, _dynamicAnchors, _quiet, schemaLocation) => {
+  Instance.setAnnotation(instance, id, schemaLocation, description);
+  return true;
+};
+
+export default { id, compile, interpret };