@hyperjump/json-schema 0.23.3 → 1.0.0

package/lib/core.js

@@ -0,0 +1,102 @@
+import curry from "just-curry-it";
+import * as PubSub from "./pubsub.js";
+import * as Configuration from "./configuration.js";
+import * as Instance from "./instance.js";
+import { InvalidSchemaError } from "./invalid-schema-error.js";
+import * as Schema from "./schema.js";
+import Validation from "./keywords/validation.js";
+
+
+export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
+Configuration.setMetaSchemaOutputFormat(FLAG);
+
+export const validate = async (url, value = undefined, outputFormat = undefined) => {
+  const compiled = await compile(url);
+  const interpretAst = (value, outputFormat) => interpret(compiled, Instance.cons(value), outputFormat);
+
+  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
+};
+
+export const compile = async (url) => {
+  const schema = await Schema.get(url);
+  const ast = { metaData: {} };
+  const schemaUri = await Validation.compile(schema, ast);
+  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 = PubSub.subscribe("result", outputHandler(outputFormat, output));
+  Validation.interpret(schemaUri, value, ast, {});
+  PubSub.unsubscribe("result", subscriptionToken);
+
+  return output[0];
+});
+
+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 = {};
+PubSub.subscribe("validate.metaValidate", async (message, schema) => {
+  if (Configuration.getShouldValidateSchema() && !schema.validated) {
+    Schema.markValidated(schema.id);
+
+    // Compile
+    if (!(schema.dialectId in metaValidators)) {
+      // Dynamic references are experimental, but are necessary for meta-validation
+      const dyanmicRefKeywordId = "https://json-schema.org/keyword/dynamicRef";
+      const isDynamicRefEnabled = Configuration.isExperimentalKeywordEnabled(dyanmicRefKeywordId);
+      Configuration.setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
+
+      const compiledSchema = await compile(schema.dialectId);
+      metaValidators[schema.dialectId] = interpret(compiledSchema);
+
+      Configuration.setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
+    }
+
+    // Interpret
+    const schemaInstance = Instance.cons(schema.schema, schema.id);
+    const metaResults = metaValidators[schema.dialectId](schemaInstance, Configuration.getMetaSchemaOutputFormat());
+    if (!metaResults.valid) {
+      throw new InvalidSchemaError(metaResults);
+    }
+  }
+});
+
+export const addSchema = (schema, url = undefined, defaultSchemaVersion = undefined) => {
+  const id = Schema.add(schema, url, defaultSchemaVersion);
+  delete metaValidators[id];
+};

package/lib/experimental.d.ts

@@ -0,0 +1,8 @@
+import type { Keyword } from "./keywords.js";
+
+
+export { compile, interpret, BASIC, DETAILED, VERBOSE } from "./core.js";
+export { isExperimentalKeywordEnabled, setExperimentalKeywordEnabled } from "./configuration.js";
+export { getKeyword, addKeyword, defineVocabulary, getKeywordName, loadDialect } from "./keywords.js";
+export type { Keyword } from "./keywords.js";
+export const Validation: Keyword<string>;

package/lib/experimental.js

@@ -0,0 +1,4 @@
+export { compile, interpret, BASIC, DETAILED, VERBOSE } from "./core.js";
+export { isExperimentalKeywordEnabled, setExperimentalKeywordEnabled } from "./configuration.js";
+export { getKeyword, addKeyword, defineVocabulary, getKeywordName, loadDialect } from "./keywords.js";
+export { default as Validation } from "./keywords/validation.js";

package/lib/fetch.browser.js

@@ -0,0 +1 @@
+export default fetch;

package/lib/fetch.js

@@ -0,0 +1,19 @@
+import fs from "fs/promises";
+import fetch, { Response } from "node-fetch";
+import Url from "url";
+import * as MediaTypes from "./media-types.js";
+
+
+export default async (url, options) => {
+  if (url.startsWith("file://")) {
+    const filePath = Url.fileURLToPath(url);
+    const fd = await fs.open(filePath);
+    const stream = fd.createReadStream();
+    return new Response(stream, {
+      url: url,
+      headers: { "Content-Type": MediaTypes.getContentType(filePath) }
+    });
+  } else {
+    return fetch(url, options);
+  }
+};

package/lib/index.d.ts

@@ -1,42 +1,11 @@
-import type { Core, Schema, Keywords, InvalidSchemaError } from "@hyperjump/json-schema-core";
-
-
-export type JsonSchema = {
-  add: typeof Schema.add;
-  get: typeof Schema.get;
-  validate: typeof Core.validate;
-  compile: typeof Core.compile;
-  interpret: typeof Core.interpret;
-  setMetaOutputFormat: typeof Core.setMetaOutputFormat;
-  setShouldMetaValidate: typeof Core.setShouldMetaValidate;
-  addMediaTypePlugin: typeof Core.addMediaTypePlugin;
-  FLAG: typeof Core.FLAG;
-  BASIC: typeof Core.BASIC;
-  DETAILED: typeof Core.DETAILED;
-  VERBOSE: typeof Core.VERBOSE;
-  Keywords: typeof Keywords;
-  InvalidSchemaError: typeof InvalidSchemaError;
-};
-
-export const add: JsonSchema["add"];
-export const get: JsonSchema["get"];
-export const validate: JsonSchema["validate"];
-export const compile: JsonSchema["compile"];
-export const interpret: JsonSchema["interpret"];
-export const setMetaOutputFormat: JsonSchema["setMetaOutputFormat"];
-export const setShouldMetaValidate: JsonSchema["setShouldMetaValidate"];
-export const addMediaTypePlugin: JsonSchema["addMediaTypePlugin"];
-export const FLAG: JsonSchema["FLAG"];
-export const BASIC: JsonSchema["BASIC"];
-export const DETAILED: JsonSchema["DETAILED"];
-export const VERBOSE: JsonSchema["VERBOSE"];
-
-export * from "@hyperjump/json-schema-core";
-export * from "./draft-04";
-export * from "./draft-06";
-export * from "./draft-07";
-export * from "./draft-2019-09";
-export * from "./draft-2020-12";
-
-declare const jsonSchema: JsonSchema;
-export default jsonSchema;
+export { addSchema, validate, FLAG } from "./core.js";
+export type { Validator, OutputFormat, CompiledSchema, Result } from "./core.js";
+export {
+  getMetaSchemaOutputFormat,
+  setMetaSchemaOutputFormat,
+  getShouldValidateSchema,
+  setShouldValidateSchema
+} from "./configuration.js";
+export { InvalidSchemaError } from "./invalid-schema-error.js";
+export { addMediaTypePlugin } from "./media-types.js";
+export type { MediaTypePlugin } from "./media-types.js";

package/lib/index.js

@@ -1,27 +1,134 @@
-const { Core, Schema, InvalidSchemaError } = require("@hyperjump/json-schema-core");
-const Keywords = require("./keywords");
+import { addKeyword } from "./keywords.js";
+import { addMediaTypePlugin } from "./media-types.js";
 
-require("./draft-04");
-require("./draft-06");
-require("./draft-07");
-require("./draft-2019-09");
-require("./draft-2020-12");
+import additionalProperties from "./keywords/additionalProperties.js";
+import allOf from "./keywords/allOf.js";
+import anchor from "./keywords/anchor.js";
+import anyOf from "./keywords/anyOf.js";
+import const_ from "./keywords/const.js";
+import contains from "./keywords/contains.js";
+import comment from "./keywords/comment.js";
+import contentEncoding from "./keywords/contentEncoding.js";
+import contentMediaType from "./keywords/contentMediaType.js";
+import contentSchema from "./keywords/contentSchema.js";
+import default_ from "./keywords/default.js";
+import definitions from "./keywords/definitions.js";
+import dependentRequired from "./keywords/dependentRequired.js";
+import dependentSchemas from "./keywords/dependentSchemas.js";
+import deprecated from "./keywords/deprecated.js";
+import description from "./keywords/description.js";
+import dynamicAnchor from "./keywords/dynamicAnchor.js";
+import dynamicRef from "./keywords/dynamicRef.js";
+import else_ from "./keywords/else.js";
+import enum_ from "./keywords/enum.js";
+import examples from "./keywords/examples.js";
+import exclusiveMaximum from "./keywords/exclusiveMaximum.js";
+import exclusiveMinimum from "./keywords/exclusiveMinimum.js";
+import format from "./keywords/format.js";
+import id from "./keywords/id.js";
+import if_ from "./keywords/if.js";
+import items from "./keywords/items.js";
+import maxContains from "./keywords/maxContains.js";
+import maxItems from "./keywords/maxItems.js";
+import maxLength from "./keywords/maxLength.js";
+import maxProperties from "./keywords/maxProperties.js";
+import maximum from "./keywords/maximum.js";
+import minContains from "./keywords/minContains.js";
+import minItems from "./keywords/minItems.js";
+import minLength from "./keywords/minLength.js";
+import minProperties from "./keywords/minProperties.js";
+import minimum from "./keywords/minimum.js";
+import multipleOf from "./keywords/multipleOf.js";
+import not from "./keywords/not.js";
+import oneOf from "./keywords/oneOf.js";
+import pattern from "./keywords/pattern.js";
+import patternProperties from "./keywords/patternProperties.js";
+import prefixItems from "./keywords/prefixItems.js";
+import properties from "./keywords/properties.js";
+import propertyDependencies from "./keywords/propertyDependencies.js";
+import propertyNames from "./keywords/propertyNames.js";
+import readOnly from "./keywords/readOnly.js";
+import ref from "./keywords/ref.js";
+import requireAllExcept from "./keywords/requireAllExcept.js";
+import required from "./keywords/required.js";
+import title from "./keywords/title.js";
+import then from "./keywords/then.js";
+import type from "./keywords/type.js";
+import unevaluatedItems from "./keywords/unevaluatedItems.js";
+import unevaluatedProperties from "./keywords/unevaluatedProperties.js";
+import uniqueItems from "./keywords/uniqueItems.js";
+import vocabulary from "./keywords/vocabulary.js";
+import writeOnly from "./keywords/writeOnly.js";
 
 
-module.exports = {
-  add: Core.add,
-  get: Schema.get,
-  validate: Core.validate,
-  compile: Core.compile,
-  interpret: Core.interpret,
-  setMetaOutputFormat: Core.setMetaOutputFormat,
-  setShouldMetaValidate: Core.setShouldMetaValidate,
-  addMediaTypePlugin: Core.addMediaTypePlugin,
-  FLAG: Core.FLAG,
-  BASIC: Core.BASIC,
-  DETAILED: Core.DETAILED,
-  VERBOSE: Core.VERBOSE,
-  Keywords: Keywords,
-  InvalidSchemaError: InvalidSchemaError
-};
+addMediaTypePlugin("application/schema+json", {
+  parse: async (response, contentTypeParameters) => [
+    await response.json(),
+    contentTypeParameters.schema || contentTypeParameters.profile
+  ],
+  matcher: (path) => path.endsWith(".schema.json")
+});
 
+addKeyword(additionalProperties);
+addKeyword(allOf);
+addKeyword(anchor);
+addKeyword(anyOf);
+addKeyword(const_);
+addKeyword(contains);
+addKeyword(comment);
+addKeyword(contentEncoding);
+addKeyword(contentMediaType);
+addKeyword(contentSchema);
+addKeyword(default_);
+addKeyword(definitions);
+addKeyword(dependentRequired);
+addKeyword(dependentSchemas);
+addKeyword(deprecated);
+addKeyword(description);
+addKeyword(dynamicAnchor);
+addKeyword(dynamicRef);
+addKeyword(else_);
+addKeyword(enum_);
+addKeyword(examples);
+addKeyword(exclusiveMaximum);
+addKeyword(exclusiveMinimum);
+addKeyword(format);
+addKeyword(id);
+addKeyword(if_);
+addKeyword(items);
+addKeyword(maxContains);
+addKeyword(maxItems);
+addKeyword(maxLength);
+addKeyword(maxProperties);
+addKeyword(maximum);
+addKeyword(minContains);
+addKeyword(minItems);
+addKeyword(minLength);
+addKeyword(minProperties);
+addKeyword(minimum);
+addKeyword(multipleOf);
+addKeyword(not);
+addKeyword(oneOf);
+addKeyword(pattern);
+addKeyword(patternProperties);
+addKeyword(prefixItems);
+addKeyword(properties);
+addKeyword(propertyDependencies);
+addKeyword(propertyNames);
+addKeyword(readOnly);
+addKeyword(ref);
+addKeyword(requireAllExcept);
+addKeyword(required);
+addKeyword(title);
+addKeyword(then);
+addKeyword(type);
+addKeyword(unevaluatedItems);
+addKeyword(unevaluatedProperties);
+addKeyword(uniqueItems);
+addKeyword(vocabulary);
+addKeyword(writeOnly);
+
+export { addSchema, validate, FLAG } from "./core.js";
+export { getMetaSchemaOutputFormat, setMetaSchemaOutputFormat, getShouldValidateSchema, setShouldValidateSchema } from "./configuration.js";
+export { InvalidSchemaError } from "./invalid-schema-error.js";
+export { addMediaTypePlugin } from "./media-types.js";

package/lib/instance.d.ts

@@ -0,0 +1,75 @@
+import type { JsonType } from "./common.js";
+import type { Json, JsonObject } 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, type: "null") => doc is JsonDocument<null>
+) & (
+  (doc: JsonDocument, type: "boolean") => doc is JsonDocument<boolean>
+) & (
+  (doc: JsonDocument, type: "object") => doc is JsonDocument<JsonObject>
+) & (
+  (doc: JsonDocument, type: "array") => doc is JsonDocument<Json[]>
+) & (
+  (doc: JsonDocument, type: "number" | "integer") => doc is JsonDocument<number>
+) & (
+  (doc: JsonDocument, type: "string") => doc is JsonDocument<string>
+) & (
+  (doc: JsonDocument, type: JsonType) => boolean
+) & (
+  (doc: JsonDocument) => (type: JsonType) => boolean
+);
+export const step: (key: string, doc: JsonDocument<JsonObject | Json[]>) => JsonDocument<typeof doc.value>;
+export const entries: (doc: JsonDocument<JsonObject>) => [string, JsonDocument][];
+export const keys: (doc: JsonDocument<JsonObject>) => string[];
+export const map: (
+  <A>(fn: MapFn<A>, doc: JsonDocument<Json[]>) => A[]
+) & (
+  <A>(fn: MapFn<A>) => (doc: JsonDocument<Json[]>) => A[]
+);
+export const forEach: (
+  (fn: ForEachFn, doc: JsonDocument<Json[]>) => void
+) & (
+  (fn: ForEachFn) => (doc: JsonDocument<Json[]>) => void
+);
+export const filter: (
+  (fn: FilterFn, doc: JsonDocument<Json[]>) => JsonDocument[]
+) & (
+  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => JsonDocument[]
+);
+export const reduce: (
+  <A>(fn: ReduceFn<A>, acc: A, doc: JsonDocument<Json[]>) => A
+) & (
+  <A>(fn: ReduceFn<A>) => (acc: A, doc: JsonDocument<Json[]>) => A
+) & (
+  <A>(fn: ReduceFn<A>) => (acc: A) => (doc: JsonDocument<Json[]>) => A
+);
+export const every: (
+  (fn: FilterFn, doc: JsonDocument<Json[]>) => boolean
+) & (
+  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => boolean
+);
+export const some: (
+  (fn: FilterFn, doc: JsonDocument<Json[]>) => boolean
+) & (
+  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => boolean
+);
+export const length: (doc: JsonDocument<Json[] | string>) => number;
+
+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 type JsonDocument<A extends Json | undefined = Json> = {
+  id: string;
+  pointer: string;
+  instance: Json;
+  value: A;
+};

package/lib/instance.js

@@ -0,0 +1,58 @@
+import * as JsonPointer from "@hyperjump/json-pointer";
+import curry from "just-curry-it";
+import { resolveUrl, jsonTypeOf } from "./common.js";
+import * as Reference from "./reference.js";
+
+
+export const nil = Object.freeze({ id: undefined, pointer: "", instance: undefined, value: undefined });
+export const cons = (instance, id = undefined) => Object.freeze({
+  ...nil,
+  id: id ? resolveUrl("", id) : "",
+  instance,
+  value: instance
+});
+
+export const get = (url, instance = nil) => {
+  if (!url.startsWith("#")) {
+    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+  }
+
+  return Object.freeze({ ...instance, pointer: url.substr(1) });
+};
+
+export const uri = (doc) => `${doc.id || ""}#${encodeURI(doc.pointer)}`;
+export const value = (doc) => Reference.isReference(doc.value) ? Reference.value(doc.value) : doc.value;
+export const has = (key, doc) => key in value(doc);
+export const typeOf = curry((doc, type) => jsonTypeOf(value(doc), type));
+
+export const step = (key, doc) => Object.freeze({
+  ...doc,
+  pointer: JsonPointer.append(key, doc.pointer),
+  value: value(doc)[key]
+});
+
+export const entries = (doc) => Object.keys(value(doc))
+  .map((key) => [key, step(key, doc)]);
+
+export const keys = (doc) => Object.keys(value(doc));
+
+export const map = curry((fn, doc) => value(doc)
+  .map((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+
+export const forEach = curry((fn, doc) => value(doc)
+  .forEach((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+
+export const filter = curry((fn, doc) => value(doc)
+  .map((item, ndx, array, thisArg) => step(ndx, doc, array, thisArg))
+  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
+
+export const reduce = curry((fn, acc, doc) => value(doc)
+  .reduce((acc, item, ndx) => fn(acc, step(ndx, doc), ndx), acc));
+
+export const every = curry((fn, doc) => value(doc)
+  .every((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+
+export const some = curry((fn, doc) => value(doc)
+  .some((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+
+export const length = (doc) => value(doc).length;

package/lib/invalid-schema-error.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from "./core.js";
+
+
+export class InvalidSchemaError extends Error {
+  public output: Result;
+
+  public constructor(output: Result);
+}

package/lib/invalid-schema-error.js

@@ -0,0 +1,7 @@
+export class InvalidSchemaError extends Error {
+  constructor(output) {
+    super("Invalid Schema");
+    this.name = this.constructor.name;
+    this.output = output;
+  }
+}

package/lib/keywords/additionalProperties.js

@@ -1,18 +1,21 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import { getKeywordName } from "../keywords.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/additionalProperties";
+
 const compile = async (schema, ast, parentSchema) => {
-  const properties = await Schema.step("properties", parentSchema);
-  const propertyNames = Schema.typeOf(properties, "object") ? Schema.keys(properties) : [];
+  const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
+  const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
+  const propertyNames = Schema.typeOf(propertiesSchema, "object") ? Schema.keys(propertiesSchema) : [];
 
-  const patternProperties = await Schema.step("patternProperties", parentSchema);
+  const patternPropertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/patternProperties");
+  const patternProperties = await Schema.step(patternPropertiesKeyword, parentSchema);
   const propertyNamePatterns = Schema.typeOf(patternProperties, "object") ? Schema.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
 
-  if (Schema.typeOf(schema, "boolean")) {
-    return [propertyNames, propertyNamePatterns, Schema.value(schema)];
-  } else {
-    return [propertyNames, propertyNamePatterns, await Core.compileSchema(schema, ast)];
-  }
+  return [propertyNames, propertyNamePatterns, await Validation.compile(schema, ast)];
 };
 
 const interpret = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
@@ -20,14 +23,13 @@ const interpret = ([propertyNames, propertyNamePatterns, additionalProperties],
     return true;
   }
 
-  const properties = Instance.entries(instance)
-    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)));
+  return Instance.entries(instance)
+    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)))
+    .every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors));
+};
 
-  if (typeof additionalProperties === "string") {
-    return properties.every(([, property]) => Core.interpretSchema(additionalProperties, property, ast, dynamicAnchors));
-  } else {
-    return properties.length === 0 || additionalProperties;
-  }
+const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/allOf.js

@@ -1,28 +1,31 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/allOf";
+
 const compile = (schema, ast) => Pact.pipeline([
-  Schema.map(async (itemSchema) => Core.compileSchema(await itemSchema, ast)),
+  Schema.map(async (itemSchema) => Validation.compile(await itemSchema, ast)),
   Pact.all
 ], schema);
 
 const interpret = (allOf, instance, ast, dynamicAnchors) => {
-  return allOf.every((schemaUrl) => Core.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+  return allOf.every((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors));
 };
 
 const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {
   return allOf.reduce((acc, schemaUrl) => {
-    const propertyNames = acc && Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = acc && Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
     return propertyNames !== false && [...acc, ...propertyNames];
   }, []);
 };
 
 const collectEvaluatedItems = (allOf, instance, ast, dynamicAnchors) => {
   return allOf.reduce((acc, schemaUrl) => {
-    const itemIndexes = acc !== false && Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = acc !== false && Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
     return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
   }, new Set());
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/anchor.js

@@ -0,0 +1 @@
+export default { id: "https://json-schema.org/keyword/anchor" };

package/lib/keywords/anyOf.js

@@ -1,29 +1,32 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/anyOf";
+
 const compile = (schema, ast) => Pact.pipeline([
-  Schema.map(async (itemSchema) => Core.compileSchema(await itemSchema, ast)),
+  Schema.map(async (itemSchema) => Validation.compile(await itemSchema, ast)),
   Pact.all
 ], schema);
 
 const interpret = (anyOf, instance, ast, dynamicAnchors) => {
-  const matches = anyOf.filter((schemaUrl) => Core.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+  const matches = anyOf.filter((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors));
   return matches.length > 0;
 };
 
 const collectEvaluatedProperties = (anyOf, instance, ast, dynamicAnchors) => {
   return anyOf.reduce((acc, schemaUrl) => {
-    const propertyNames = Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
     return propertyNames !== false ? [...acc || [], ...propertyNames] : acc;
   }, false);
 };
 
 const collectEvaluatedItems = (anyOf, instance, ast, dynamicAnchors) => {
   return anyOf.reduce((acc, schemaUrl) => {
-    const itemIndexes = Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
     return itemIndexes !== false ? new Set([...acc || [], ...itemIndexes]) : acc;
   }, false);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/comment.js

@@ -0,0 +1,4 @@
+import metaData from "./meta-data.js";
+
+
+export default { id: "https://json-schema.org/keyword/comment", ...metaData };