@hyperjump/json-schema 0.23.3 → 1.0.0

package/lib/keywords/const.js

@@ -1,8 +1,11 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
-const jsonStringify = require("fastest-stable-stringify");
+import jsonStringify from "fastest-stable-stringify";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/const";
+
 const compile = (schema) => jsonStringify(Schema.value(schema));
 const interpret = (const_, instance) => jsonStringify(Instance.value(instance)) === const_;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/contains.js

@@ -1,10 +1,53 @@
-const { Core, 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 compile = (schema, ast) => Core.compileSchema(schema, ast);
+const id = "https://json-schema.org/keyword/contains";
 
-const interpret = (contains, instance, ast, dynamicAnchors) => {
-  return !Instance.typeOf(instance, "array") || Instance.some((item) => Core.interpretSchema(contains, item, ast, dynamicAnchors), instance);
+const compile = async (schema, ast, parentSchema) => {
+  const contains = await Validation.compile(schema, ast);
+
+  const minContainsKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/minContains");
+  const minContainsSchema = await Schema.step(minContainsKeyword, parentSchema);
+  const minContains = Schema.typeOf(minContainsSchema, "number") ? Schema.value(minContainsSchema) : 1;
+
+  const maxContainsKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/maxContains");
+  const maxContainsSchema = await Schema.step(maxContainsKeyword, parentSchema);
+  const maxContains = Schema.typeOf(maxContainsSchema, "number") ? Schema.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
+
+  return { contains, minContains, maxContains };
+};
+
+const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array") && !Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  const matches = Instance.entries(instance).reduce((matches, [, item]) => {
+    return Validation.interpret(contains, item, ast, dynamicAnchors) ? matches + 1 : matches;
+  }, 0);
+  return matches >= minContains && matches <= maxContains;
+};
+
+const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) &&
+    Instance.typeOf(instance, "array") &&
+    Instance.reduce((matchedIndexes, item, itemIndex) => {
+      return Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
+    }, new Set(), instance);
+};
+
+const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) &&
+    Instance.typeOf(instance, "object") &&
+    Instance.entries(instance).reduce((matchedPropertyNames, [propertyName, item]) => {
+      if (Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors)) {
+        matchedPropertyNames.push(propertyName);
+      }
+      return matchedPropertyNames;
+    }, [], instance);
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret, collectEvaluatedItems, collectEvaluatedProperties };

package/lib/keywords/contentEncoding.js

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

package/lib/keywords/contentMediaType.js

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

package/lib/keywords/contentSchema.js

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

package/lib/keywords/default.js

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

package/lib/keywords/definitions.js

@@ -1,15 +1,18 @@
-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/definitions";
+
 const compile = async (schema, ast) => {
   await Pact.pipeline([
     Schema.entries,
-    Pact.map(([, definitionSchema]) => Core.compileSchema(definitionSchema, ast)),
+    Pact.map(([, definitionSchema]) => Validation.compile(definitionSchema, ast)),
     Pact.all
   ], schema);
 };
 
 const interpret = () => true;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/dependentRequired.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/dependentRequired";
+
 const compile = (schema) => Pact.pipeline([
   Schema.entries,
   Pact.map(([key, dependentRequired]) => [key, Schema.value(dependentRequired)]),
@@ -16,4 +19,4 @@ const interpret = (dependentRequired, instance) => {
   });
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/dependentSchemas.js

@@ -1,10 +1,14 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/dependentSchemas";
+
 const compile = (schema, ast) => Pact.pipeline([
   Schema.entries,
-  Pact.map(async ([key, dependentSchema]) => [key, await Core.compileSchema(dependentSchema, ast)]),
+  Pact.map(async ([key, dependentSchema]) => [key, await Validation.compile(dependentSchema, ast)]),
   Pact.all
 ], schema);
 
@@ -12,7 +16,7 @@ const interpret = (dependentSchemas, instance, ast, dynamicAnchors) => {
   const value = Instance.value(instance);
 
   return !Instance.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
-    return !(propertyName in value) || Core.interpretSchema(dependentSchema, instance, ast, dynamicAnchors);
+    return !(propertyName in value) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors);
   });
 };
 
@@ -22,9 +26,9 @@ const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnch
       return acc;
     }
 
-    const propertyNames = Core.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
     return propertyNames !== false && acc.concat(propertyNames);
   }, []);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/deprecated.js

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

package/lib/keywords/description.js

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

package/lib/keywords/dynamicAnchor.js

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

package/lib/keywords/dynamicRef.js

@@ -1,24 +1,20 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
-const { splitUrl } = require("../common");
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
 
 
-const compile = async (dynamicRef, ast) => {
-  const [, fragment] = splitUrl(Schema.value(dynamicRef));
-  const referencedSchema = await Schema.get(Schema.value(dynamicRef), dynamicRef);
-  await Core.compileSchema(referencedSchema, ast);
-  return [referencedSchema.id, fragment];
-};
+const id = "https://json-schema.org/keyword/dynamicRef";
+const experimental = true;
+
+const compile = Schema.value;
 
-const interpret = ([id, fragment], instance, ast, dynamicAnchors) => {
-  if (fragment in ast.metaData[id].dynamicAnchors) {
-    return Core.interpretSchema(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
-  } else {
-    const pointer = Schema.getAnchorPointer(ast.metaData[id], fragment);
-    return Core.interpretSchema(`${id}#${encodeURI(pointer)}`, instance, ast, dynamicAnchors);
+const interpret = (fragment, instance, ast, dynamicAnchors) => {
+  if (!(fragment in dynamicAnchors)) {
+    throw Error(`No dynamic anchor found for "${fragment}"`);
   }
+  return Validation.interpret(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
 };
 
-const collectEvaluatedProperties = Core.collectEvaluatedProperties;
-const collectEvaluatedItems = Core.collectEvaluatedItems;
+const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
+const collectEvaluatedItems = Validation.collectEvaluatedItems;
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, experimental, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/else.js

@@ -1,26 +1,31 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import { getKeywordName, getKeyword } from "../keywords.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/else";
+
 const compile = async (schema, ast, parentSchema) => {
-  if (Schema.has("if", parentSchema)) {
-    const ifSchema = await Schema.step("if", parentSchema);
-    return [await Core.compileSchema(ifSchema, ast), await Core.compileSchema(schema, ast)];
+  const ifKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/if");
+  if (Schema.has(ifKeyword, parentSchema)) {
+    const ifSchema = await Schema.step(ifKeyword, parentSchema);
+    return [await Validation.compile(ifSchema, ast), await Validation.compile(schema, ast)];
   } else {
     return [];
   }
 };
 
 const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
-  return guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Core.interpretSchema(block, instance, ast, dynamicAnchors);
+  return guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Validation.interpret(block, instance, ast, dynamicAnchors);
 };
 
 // Interpret a schema without events being emitted
-const quietInterpretSchema = (uri, instance, ast, dynamicAnchors) => {
-  const nodes = ast[uri][2];
+const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
+  const nodes = ast[url][2];
 
   return typeof nodes === "boolean" ? nodes : nodes
     .every(([keywordId, , keywordValue]) => {
-      return Core.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+      return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
     });
 };
 
@@ -29,7 +34,7 @@ const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchor
     return [];
   }
 
-  return Core.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
 };
 
 const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) => {
@@ -37,7 +42,7 @@ const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) =>
     return new Set();
   }
 
-  return Core.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/enum.js

@@ -1,8 +1,11 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
-const jsonStringify = require("fastest-stable-stringify");
+import jsonStringify from "fastest-stable-stringify";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/enum";
+
 const compile = (schema) => Schema.value(schema).map(jsonStringify);
 const interpret = (enum_, instance) => enum_.some((enumValue) => jsonStringify(Instance.value(instance)) === enumValue);
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/examples.js

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

package/lib/keywords/exclusiveMaximum.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/exclusiveMaximum";
+
 const compile = async (schema) => Schema.value(schema);
 const interpret = (exclusiveMaximum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) < exclusiveMaximum;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/exclusiveMinimum.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/exclusiveMinimum";
+
 const compile = async (schema) => Schema.value(schema);
 const interpret = (exclusiveMinimum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) > exclusiveMinimum;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/format.js

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

package/lib/keywords/id.js

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

package/lib/keywords/if.js

@@ -1,19 +1,21 @@
-const { Core } = require("@hyperjump/json-schema-core");
+import Validation from "./validation.js";
 
 
-const compile = (schema, ast) => Core.compileSchema(schema, ast);
+const id = "https://json-schema.org/keyword/if";
+
+const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (ifSchema, instance, ast, dynamicAnchors) => {
-  Core.interpretSchema(ifSchema, instance, ast, dynamicAnchors);
+  Validation.interpret(ifSchema, instance, ast, dynamicAnchors);
   return true;
 };
 
 const collectEvaluatedProperties = (ifSchema, instance, ast, dynamicAnchors) => {
-  return Core.collectEvaluatedProperties(ifSchema, instance, ast, dynamicAnchors) || [];
+  return Validation.collectEvaluatedProperties(ifSchema, instance, ast, dynamicAnchors) || [];
 };
 
 const collectEvaluatedItems = (ifSchema, instance, ast, dynamicAnchors) => {
-  return Core.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
+  return Validation.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/items.js

@@ -1,31 +1,29 @@
-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 compile = async (schema, ast) => {
-  if (Schema.typeOf(schema, "array")) {
-    const tupleItems = await Schema.map((itemSchema) => Core.compileSchema(itemSchema, ast), schema);
-    return Promise.all(tupleItems);
-  } else {
-    return Core.compileSchema(schema, ast);
-  }
+const id = "https://json-schema.org/keyword/items";
+
+const compile = async (schema, ast, parentSchema) => {
+  const prefixItemKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/prefixItems");
+  const items = await Schema.step(prefixItemKeyword, parentSchema);
+  const numberOfPrefixItems = Schema.typeOf(items, "array") ? Schema.length(items) : 0;
+
+  return [numberOfPrefixItems, await Validation.compile(schema, ast)];
 };
 
-const interpret = (items, instance, ast, dynamicAnchors) => {
+const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
   if (!Instance.typeOf(instance, "array")) {
     return true;
   }
 
-  if (typeof items === "string") {
-    return Instance.every((itemValue) => Core.interpretSchema(items, itemValue, ast, dynamicAnchors), instance);
-  } else {
-    return Instance.every((item, ndx) => !(ndx in items) || Core.interpretSchema(items[ndx], item, ast, dynamicAnchors), instance);
-  }
+  return Instance.every((item, ndx) => ndx < numberOfPrefixItems || Validation.interpret(items, item, ast, dynamicAnchors), instance);
 };
 
-const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
-  return interpret(items, instance, ast, dynamicAnchors) && (typeof items === "string"
-    ? new Set(Instance.map((item, itemIndex) => itemIndex, instance))
-    : new Set(items.map((item, itemIndex) => itemIndex)));
+const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance.map((item, ndx) => ndx, instance));
 };
 
-module.exports = { compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/maxContains.js

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

package/lib/keywords/maxItems.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/maxItems";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (maxItems, instance) => !Instance.typeOf(instance, "array") || Instance.length(instance) <= maxItems;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/maxLength.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/maxLength";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (maxLength, instance) => !Instance.typeOf(instance, "string") || [...Instance.value(instance)].length <= maxLength;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/maxProperties.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/maxProperties";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (maxProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length <= maxProperties;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/maximum.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/maximum";
+
 const compile = async (schema) => Schema.value(schema);
 const interpret = (maximum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) <= maximum;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/meta-data.js

@@ -0,0 +1,4 @@
+const compile = (schema) => schema.value;
+const interpret = () => true;
+
+export default { compile, interpret };

package/lib/keywords/minContains.js

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

package/lib/keywords/minItems.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/minItems";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (minItems, instance) => !Instance.typeOf(instance, "array") || Instance.length(instance) >= minItems;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/minLength.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/minLength";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (minLength, instance) => !Instance.typeOf(instance, "string") || [...Instance.value(instance)].length >= minLength;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/minProperties.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/minProperties";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (minProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length >= minProperties;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/minimum.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/minimum";
+
 const compile = async (schema) => Schema.value(schema);
 const interpret = (minimum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) >= minimum;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/multipleOf.js

@@ -1,6 +1,9 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/multipleOf";
+
 const compile = (schema) => Schema.value(schema);
 
 const interpret = (multipleOf, instance) => {
@@ -14,4 +17,4 @@ const interpret = (multipleOf, instance) => {
 
 const numberEqual = (a, b) => Math.abs(a - b) < 1.19209290e-7;
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/not.js

@@ -1,7 +1,9 @@
-const { Core } = require("@hyperjump/json-schema-core");
+import Validation from "./validation.js";
 
 
-const compile = Core.compileSchema;
-const interpret = (not, instance, ast, dynamicAnchors) => !Core.interpretSchema(not, instance, ast, dynamicAnchors);
+const id = "https://json-schema.org/keyword/not";
 
-module.exports = { compile, interpret };
+const compile = Validation.compile;
+const interpret = (not, instance, ast, dynamicAnchors) => !Validation.interpret(not, instance, ast, dynamicAnchors);
+
+export default { id, compile, interpret };