@hyperjump/json-schema 1.6.7 → 1.7.0

package/lib/instance.js

@@ -1,7 +1,7 @@
 import { append as pointerAppend, get as pointerGet } from "@hyperjump/json-pointer";
 import { toAbsoluteIri } from "@hyperjump/uri";
-import curry from "just-curry-it";
 import { jsonTypeOf } from "./common.js";
+import { Reference } from "@hyperjump/browser/jref";
 
 
 export const nil = { id: undefined, pointer: "", instance: undefined, value: undefined };
@@ -26,9 +26,9 @@ export const get = (url, instance = nil) => {
 };
 
 export const uri = (doc) => `${doc.id || ""}#${encodeURI(doc.pointer)}`;
-export const value = (doc) => doc.value;
+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 = curry((doc, type) => jsonTypeOf(value(doc), type));
+export const typeOf = (doc) => jsonTypeOf(value(doc));
 
 export const step = (key, doc) => ({
   ...doc,

package/lib/keywords/additionalProperties.js

@@ -1,23 +1,22 @@
 import { concat, join, empty, map, filter, every, pipe } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import { getKeywordName } from "../keywords.js";
-import Validation from "./validation.js";
+import { getKeywordName, Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/additionalProperties";
 
 const compile = async (schema, ast, parentSchema) => {
-  const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
-  const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
-  const propertyPatterns = Schema.typeOf(propertiesSchema, "object")
-    ? map((propertyName) => "^" + regexEscape(propertyName) + "$", Schema.keys(propertiesSchema))
+  const propertiesKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/properties");
+  const propertiesSchema = await Browser.step(propertiesKeyword, parentSchema);
+  const propertyPatterns = Browser.typeOf(propertiesSchema) === "object"
+    ? map((propertyName) => "^" + regexEscape(propertyName) + "$", Browser.keys(propertiesSchema))
     : empty();
 
-  const patternPropertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/patternProperties");
-  const patternProperties = await Schema.step(patternPropertiesKeyword, parentSchema);
-  const patternPropertyPatterns = Schema.typeOf(patternProperties, "object")
-    ? Schema.keys(patternProperties)
+  const patternPropertiesKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/patternProperties");
+  const patternProperties = await Browser.step(patternPropertiesKeyword, parentSchema);
+  const patternPropertyPatterns = Browser.typeOf(patternProperties) === "object"
+    ? Browser.keys(patternProperties)
     : empty();
 
   const pattern = pipe(
@@ -33,7 +32,7 @@ const regexEscape = (string) => string
   .replace(/-/g, "\\x2d");
 
 const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
@@ -45,7 +44,7 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dyn
 };
 
 const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 

package/lib/keywords/allOf.js

@@ -1,12 +1,12 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/allOf";
 
 const compile = (schema, ast) => pipe(
-  Schema.iter(schema),
+  Browser.iter(schema),
   asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
   asyncCollectArray
 );

package/lib/keywords/anyOf.js

@@ -1,12 +1,12 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/anyOf";
 
 const compile = (schema, ast) => pipe(
-  Schema.iter(schema),
+  Browser.iter(schema),
   asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
   asyncCollectArray
 );

package/lib/keywords/conditional.js

@@ -1,13 +1,12 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/conditional";
-const experimental = true;
 
 const compile = (schema, ast) => pipe(
-  Schema.iter(schema),
+  Browser.iter(schema),
   schemaFlatten,
   asyncMap((subSchema) => Validation.compile(subSchema, ast)),
   asyncCollectArray
@@ -54,12 +53,12 @@ const collectEvaluatedItems = (conditional, instance, ast, dynamicAnchors) => {
 
 const schemaFlatten = async function* (iter, depth = 1) {
   for await (const n of iter) {
-    if (depth > 0 && Schema.typeOf(n, "array")) {
-      yield* schemaFlatten(Schema.iter(n), depth - 1);
+    if (depth > 0 && Browser.typeOf(n) === "array") {
+      yield* schemaFlatten(Browser.iter(n), depth - 1);
     } else {
       yield n;
     }
   }
 };
 
-export default { id, experimental, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/const.js

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

package/lib/keywords/contains.js

@@ -1,8 +1,7 @@
-import { pipe, map, filter, count, collectSet, zip, range } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import { pipe, filter, reduce, zip, range, map, collectSet } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import { getKeywordName } from "../keywords.js";
-import Validation from "./validation.js";
+import { getKeywordName, Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/contains";
@@ -10,49 +9,29 @@ const id = "https://json-schema.org/keyword/contains";
 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 minContainsKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/minContains");
+  const minContainsSchema = await Browser.step(minContainsKeyword, parentSchema);
+  const minContains = Browser.typeOf(minContainsSchema) === "number" ? Browser.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;
+  const maxContainsKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/maxContains");
+  const maxContainsSchema = await Browser.step(maxContainsKeyword, parentSchema);
+  const maxContains = Browser.typeOf(maxContainsSchema) === "number" ? Browser.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
 
   return { contains, minContains, maxContains };
 };
 
 const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors, quiet) => {
-  let iterator;
-  if (Instance.typeOf(instance, "array")) {
-    iterator = Instance.iter(instance);
-  } else if (Instance.typeOf(instance, "object")) {
-    iterator = Instance.values(instance);
-  } else {
-    return true;
-  }
-
-  const matches = pipe(
-    iterator,
+  const matches = Instance.typeOf(instance) !== "array" || pipe(
+    Instance.iter(instance),
     filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
-    count
+    reduce((matches) => matches + 1, 0)
   );
   return matches >= minContains && matches <= maxContains;
 };
 
-const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors, true)
-    && Instance.typeOf(instance, "object")
-    && pipe(
-      Instance.entries(instance),
-      filter(([, item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
-      map(([propertyName]) => propertyName),
-      collectSet
-    );
-};
-
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
   return interpret(keywordValue, instance, ast, dynamicAnchors, true)
-    && Instance.typeOf(instance, "array")
+    && Instance.typeOf(instance) === "array"
     && pipe(
       zip(Instance.iter(instance), range(0)),
       filter(([item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
@@ -61,4 +40,4 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
     );
 };
 
-export default { id, compile, interpret, collectEvaluatedItems, collectEvaluatedProperties };
+export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/contentSchema.js

@@ -3,7 +3,7 @@ import * as Schema from "../schema.js";
 
 const id = "https://json-schema.org/keyword/contentSchema";
 
-const compile = (contentSchema) => Schema.uri(contentSchema);
+const compile = (contentSchema) => Schema.canonicalUri(contentSchema);
 const interpret = () => true;
 
 export default { id, compile, interpret };

package/lib/keywords/definitions.js

@@ -1,12 +1,12 @@
+import * as Browser from "@hyperjump/browser";
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
 import Validation from "./validation.js";
 
 
 const id = "https://json-schema.org/keyword/definitions";
 
 const compile = (schema, ast) => pipe(
-  Schema.values(schema),
+  Browser.values(schema),
   asyncMap((definitionSchema) => Validation.compile(definitionSchema, ast)),
   asyncCollectArray
 );

package/lib/keywords/dependentRequired.js

@@ -1,18 +1,18 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/dependentRequired";
 
 const compile = (schema) => pipe(
-  Schema.entries(schema),
-  asyncMap(([key, dependentRequired]) => [key, Schema.value(dependentRequired)]),
+  Browser.entries(schema),
+  asyncMap(([key, dependentRequired]) => [key, Browser.value(dependentRequired)]),
   asyncCollectArray
 );
 
 const interpret = (dependentRequired, instance) => {
-  return !Instance.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
+  return Instance.typeOf(instance) !== "object" || dependentRequired.every(([propertyName, required]) => {
     return !Instance.has(propertyName, instance) || required.every((key) => Instance.has(key, instance));
   });
 };

package/lib/keywords/dependentSchemas.js

@@ -1,25 +1,25 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/dependentSchemas";
 
 const compile = (schema, ast) => pipe(
-  Schema.entries(schema),
+  Browser.entries(schema),
   asyncMap(async ([key, dependentSchema]) => [key, await Validation.compile(dependentSchema, ast)]),
   asyncCollectArray
 );
 
 const interpret = (dependentSchemas, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
+  return Instance.typeOf(instance) !== "object" || dependentSchemas.every(([propertyName, dependentSchema]) => {
     return !Instance.has(propertyName, instance) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
   });
 };
 
 const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return false;
   }
 

package/lib/keywords/dynamicRef.js

@@ -1,11 +1,16 @@
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/dynamicRef";
-const experimental = true;
 
-const compile = Schema.value;
+const compile = async (schema, ast) => {
+  const reference = Browser.value(schema);
+  const self = await Browser.get(schema.document.baseUri, schema);
+  await Validation.compile(self, ast);
+
+  return reference;
+};
 
 const evaluate = (strategy) => (fragment, instance, ast, dynamicAnchors, quiet) => {
   if (!(fragment in dynamicAnchors)) {
@@ -18,4 +23,4 @@ const interpret = evaluate(Validation.interpret);
 const collectEvaluatedProperties = evaluate(Validation.collectEvaluatedProperties);
 const collectEvaluatedItems = evaluate(Validation.collectEvaluatedItems);
 
-export default { id, experimental, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/else.js

@@ -1,14 +1,13 @@
-import * as Schema from "../schema.js";
-import { getKeywordName } from "../keywords.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { getKeywordName, Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/else";
 
 const compile = async (schema, ast, parentSchema) => {
-  const ifKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/if");
-  if (Schema.has(ifKeyword, parentSchema)) {
-    const ifSchema = await Schema.step(ifKeyword, parentSchema);
+  const ifKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/if");
+  if (Browser.has(ifKeyword, parentSchema)) {
+    const ifSchema = await Browser.step(ifKeyword, parentSchema);
     return [await Validation.compile(ifSchema, ast), await Validation.compile(schema, ast)];
   } else {
     return [];

package/lib/keywords/enum.js

@@ -1,14 +1,14 @@
-import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import jsonStringify from "fastest-stable-stringify";
-import * as Schema from "../schema.js";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/enum";
 
 const compile = (schema) => pipe(
-  Schema.iter(schema),
-  asyncMap(Schema.value),
+  Browser.iter(schema),
+  asyncMap(Browser.value),
   asyncMap(jsonStringify),
   asyncCollectArray
 );

package/lib/keywords/exclusiveMaximum.js

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

package/lib/keywords/exclusiveMinimum.js

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

package/lib/keywords/if.js

@@ -1,4 +1,4 @@
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/if";

package/lib/keywords/itemPattern.js

@@ -1,19 +1,18 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 import { fromEpsilon, fromSchema, closure, zeroOrOne, oneOrMore, concat, union } from "../nfa.js";
 
 
 const id = "https://json-schema.org/keyword/itemPattern";
-const experimental = true;
 
 const compile = async (schema, ast) => {
   const groups = [[]];
   let group = groups[0];
 
-  for await (const rule of Schema.iter(schema)) {
-    if (Schema.typeOf(rule, "string")) {
-      const operator = Schema.value(rule);
+  for await (const rule of Browser.iter(schema)) {
+    if (Browser.typeOf(rule) === "string") {
+      const operator = Browser.value(rule);
 
       if (operator === "*") {
         group.push(closure(group.pop()));
@@ -28,20 +27,20 @@ const compile = async (schema, ast) => {
         throw Error(`Unsupported pattern syntax: ${operator}`);
       }
     } else {
-      const node = Schema.typeOf(rule, "array")
+      const node = Browser.typeOf(rule) === "array"
         ? compile(rule, ast)
         : fromSchema(await Validation.compile(rule, ast));
       group.push(await node);
     }
   }
 
-  return Schema.length(schema) === 0 ? fromEpsilon() : groups
+  return Browser.length(schema) === 0 ? fromEpsilon() : groups
     .map((group) => group.reduce(concat))
     .reduce(union);
 };
 
-const interpret = (nfa, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
+const evaluate = (strategy) => (nfa, instance, ast, dynamicAnchors, quiet) => {
+  if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 
@@ -52,7 +51,7 @@ const interpret = (nfa, instance, ast, dynamicAnchors, quiet) => {
     const nextStates = [];
 
     for (const state of currentStates) {
-      const nextState = transition(state.transition, item, ast, dynamicAnchors, quiet);
+      const nextState = transition(strategy, state.transition, item, ast, dynamicAnchors, quiet);
       if (nextState) {
         addNextState(nextState, nextStates, []);
       }
@@ -77,12 +76,16 @@ const addNextState = (state, nextStates, visited) => {
   }
 };
 
-const transition = (transitions, instance, ast, dynamicAnchors, quiet) => {
+const transition = (strategy, transitions, instance, ast, dynamicAnchors, quiet) => {
   for (const schema in transitions) {
-    if (Validation.interpret(schema, instance, ast, dynamicAnchors, quiet)) {
+    if (strategy(schema, instance, ast, dynamicAnchors, quiet)) {
       return transitions[schema];
     }
   }
 };
 
-export default { id, experimental, compile, interpret };
+const interpret = evaluate(Validation.interpret);
+const collectEvalatedProperties = evaluate(Validation.collectEvaluatedProperties);
+const collectEvalatedItems = evaluate(Validation.collectEvaluatedItems);
+
+export default { id, compile, interpret, collectEvalatedProperties, collectEvalatedItems };

package/lib/keywords/items.js

@@ -1,22 +1,21 @@
 import { pipe, drop, every } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import { getKeywordName } from "../keywords.js";
-import Validation from "./validation.js";
+import { getKeywordName, Validation } from "../experimental.js";
 
 
 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 prefixItems = await Schema.step(prefixItemKeyword, parentSchema);
-  const numberOfPrefixItems = Schema.typeOf(prefixItems, "array") ? Schema.length(prefixItems) : 0;
+  const prefixItemKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/prefixItems");
+  const prefixItems = await Browser.step(prefixItemKeyword, parentSchema);
+  const numberOfPrefixItems = Browser.typeOf(prefixItems) === "array" ? Browser.length(prefixItems) : 0;
 
   return [numberOfPrefixItems, await Validation.compile(schema, ast)];
 };
 
 const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
+  if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 

package/lib/keywords/maxItems.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 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;
+const compile = (schema) => Browser.value(schema);
+const interpret = (maxItems, instance) => Instance.typeOf(instance) !== "array" || Instance.length(instance) <= maxItems;
 
 export default { id, compile, interpret };

package/lib/keywords/maxLength.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 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;
+const compile = (schema) => Browser.value(schema);
+const interpret = (maxLength, instance) => Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length <= maxLength;
 
 export default { id, compile, interpret };

package/lib/keywords/maxProperties.js

@@ -1,12 +1,12 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/maxProperties";
 
-const compile = (schema) => Schema.value(schema);
+const compile = (schema) => Browser.value(schema);
 const interpret = (maxProperties, instance) => {
-  return !Instance.typeOf(instance, "object") || [...Instance.keys(instance)].length <= maxProperties;
+  return Instance.typeOf(instance) !== "object" || [...Instance.keys(instance)].length <= maxProperties;
 };
 
 export default { id, compile, interpret };

package/lib/keywords/maximum.js

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

package/lib/keywords/meta-data.js

@@ -1,4 +1,4 @@
-import { value } from "../schema.js";
+import { value } from "@hyperjump/browser";
 
 
 const compile = value;

package/lib/keywords/minItems.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 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;
+const compile = (schema) => Browser.value(schema);
+const interpret = (minItems, instance) => Instance.typeOf(instance) !== "array" || Instance.length(instance) >= minItems;
 
 export default { id, compile, interpret };

package/lib/keywords/minLength.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 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;
+const compile = (schema) => Browser.value(schema);
+const interpret = (minLength, instance) => Instance.typeOf(instance) !== "string" || [...Instance.value(instance)].length >= minLength;
 
 export default { id, compile, interpret };