@hyperjump/json-schema 1.1.0 → 1.1.2

package/draft-04/maximum.js

@@ -7,7 +7,6 @@ const id = "https://json-schema.org/keyword/draft-04/maximum";
 
 const compile = async (schema, ast, parentSchema) => {
   const exclusiveMaximumKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
-  console.log(exclusiveMaximumKeyword);
   const exclusiveMaximum = await Schema.step(exclusiveMaximumKeyword, parentSchema);
   const isExclusive = Schema.value(exclusiveMaximum);
 

package/draft-2019-09/recursiveRef.js

@@ -3,10 +3,11 @@ import Validation from "../lib/keywords/validation.js";
 
 const id = "https://json-schema.org/keyword/draft-2019-09/recursiveRef";
 
-const compile = async (schema) => schema.id;
+const compile = (schema) => schema.id;
 
 const interpret = (id, instance, ast, dynamicAnchors) => {
   if ("" in ast.metaData[id].dynamicAnchors) {
+    dynamicAnchors = { ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors };
     return Validation.interpret(dynamicAnchors[""], instance, ast, dynamicAnchors);
   } else {
     return Validation.interpret(`${id}#`, instance, ast, dynamicAnchors);

package/draft-2020-12/dynamicRef.js

@@ -1,19 +1,20 @@
 import Validation from "../lib/keywords/validation.js";
 import * as Schema from "../lib/schema.js";
+import { uriFragment } from "../lib/common.js";
 
 
 const id = "https://json-schema.org/keyword/draft-2020-12/dynamicRef";
 
 const compile = async (dynamicRef, ast) => {
-  const [, fragment] = splitUrl(Schema.value(dynamicRef));
+  const fragment = uriFragment(Schema.value(dynamicRef));
   const referencedSchema = await Schema.get(Schema.value(dynamicRef), dynamicRef);
   await Validation.compile(referencedSchema, ast);
   return [referencedSchema.id, fragment, Schema.uri(referencedSchema)];
-
 };
 
 const interpret = ([id, fragment, ref], instance, ast, dynamicAnchors) => {
   if (fragment in ast.metaData[id].dynamicAnchors) {
+    dynamicAnchors = { ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors };
     return Validation.interpret(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
   } else {
     return Validation.interpret(ref, instance, ast, dynamicAnchors);
@@ -23,13 +24,4 @@ const interpret = ([id, fragment, ref], instance, ast, dynamicAnchors) => {
 const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
 const collectEvaluatedItems = Validation.collectEvaluatedItems;
 
-const splitUrl = (url) => {
-  const indexOfHash = url.indexOf("#");
-  const ndx = indexOfHash === -1 ? url.length : indexOfHash;
-  const urlReference = url.slice(0, ndx);
-  const urlFragment = url.slice(ndx + 1);
-
-  return [decodeURI(urlReference), decodeURI(urlFragment)];
-};
-
 export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/common.js

@@ -1,3 +1,6 @@
+import { resolveIri, toAbsoluteIri, parseIriReference } from "@hyperjump/uri";
+
+
 const isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
 const isType = {
   null: (value) => value === null,
@@ -10,15 +13,16 @@ const isType = {
 };
 export const jsonTypeOf = (value, type) => isType[type](value);
 
-export const resolveUrl = (url, baseUri = undefined) => {
-  const resolved = new URL(url, baseUri);
-  if (baseUri && new URL("", baseUri).protocol !== "file:" && resolved.protocol === "file:") {
-    throw Error(`Can't access file '${resolved.href}' resource from network context '${baseUri}'`);
+export const resolveUri = (uri, baseUri) => {
+  const resolved = resolveIri(uri, baseUri);
+  if (resolved.startsWith("file:") && baseUri && !baseUri.startsWith("file:")) {
+    throw Error(`Can't access file '${resolved}' resource from network context '${baseUri}'`);
   }
-  return resolved.href;
+  return resolved;
 };
 
-export const urlFragment = (url) => decodeURIComponent(new URL(url).hash.slice(1));
+export const toAbsoluteUri = (uri) => toAbsoluteIri(uri);
+export const uriFragment = (uri) => decodeURIComponent(parseIriReference(uri).fragment || "");
 
 const CHAR_BACKWARD_SLASH = 47;
 

package/lib/configuration.js

@@ -1,6 +1,6 @@
 let metaSchemaOutputFormat;
 let shouldValidateSchema = true;
-let enabledExperimentalKeywords = {};
+const enabledExperimentalKeywords = {};
 
 export const getMetaSchemaOutputFormat = () => metaSchemaOutputFormat;
 export const setMetaSchemaOutputFormat = (format) => {

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export { addSchema, validate, FLAG } from "./core.js";
-export type { Validator, OutputFormat, CompiledSchema, Result } from "./core.js";
+export type { Validator, OutputFormat, CompiledSchema, OutputUnit } from "./core.js";
 export {
   getMetaSchemaOutputFormat,
   setMetaSchemaOutputFormat,

package/lib/instance.js

@@ -1,13 +1,13 @@
 import * as JsonPointer from "@hyperjump/json-pointer";
 import curry from "just-curry-it";
-import { resolveUrl, jsonTypeOf } from "./common.js";
+import { toAbsoluteUri, 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({
+export const nil = { id: undefined, pointer: "", instance: undefined, value: undefined };
+export const cons = (instance, id = undefined) => ({
   ...nil,
-  id: id ? resolveUrl("", id) : "",
+  id: id ? toAbsoluteUri(id) : "",
   instance,
   value: instance
 });
@@ -17,7 +17,7 @@ export const get = (url, instance = nil) => {
     throw Error(`No JSON document found at '${url.split("#")[0]}'`);
   }
 
-  return Object.freeze({ ...instance, pointer: url.substr(1) });
+  return { ...instance, pointer: url.substr(1) };
 };
 
 export const uri = (doc) => `${doc.id || ""}#${encodeURI(doc.pointer)}`;
@@ -25,7 +25,7 @@ export const value = (doc) => Reference.isReference(doc.value) ? Reference.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({
+export const step = (key, doc) => ({
   ...doc,
   pointer: JsonPointer.append(key, doc.pointer),
   value: value(doc)[key]

package/lib/keywords/anyOf.js

@@ -18,14 +18,14 @@ const interpret = (anyOf, instance, ast, dynamicAnchors) => {
 const collectEvaluatedProperties = (anyOf, instance, ast, dynamicAnchors) => {
   return anyOf.reduce((acc, schemaUrl) => {
     const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
-    return propertyNames !== false ? [...acc || [], ...propertyNames] : acc;
+    return propertyNames === false ? acc : [...acc || [], ...propertyNames];
   }, false);
 };
 
 const collectEvaluatedItems = (anyOf, instance, ast, dynamicAnchors) => {
   return anyOf.reduce((acc, schemaUrl) => {
     const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
-    return itemIndexes !== false ? new Set([...acc || [], ...itemIndexes]) : acc;
+    return itemIndexes === false ? acc : new Set([...acc || [], ...itemIndexes]);
   }, false);
 };
 

package/lib/keywords/contains.js

@@ -32,17 +32,17 @@ const interpret = ({ contains, minContains, maxContains }, instance, ast, dynami
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors) &&
-    Instance.typeOf(instance, "array") &&
-    Instance.reduce((matchedIndexes, item, itemIndex) => {
+  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]) => {
+  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);
       }

package/lib/keywords/else.js

@@ -23,10 +23,9 @@ const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
 const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
   const nodes = ast[url][2];
 
-  return typeof nodes === "boolean" ? nodes : nodes
-    .every(([keywordId, , keywordValue]) => {
-      return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
-    });
+  return typeof nodes === "boolean" ? nodes : nodes.every(([keywordId, , keywordValue]) => {
+    return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+  });
 };
 
 const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchors) => {

package/lib/keywords/exclusiveMaximum.js

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

package/lib/keywords/exclusiveMinimum.js

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

package/lib/keywords/maximum.js

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

package/lib/keywords/minimum.js

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

package/lib/keywords/propertyDependencies.js

@@ -7,7 +7,7 @@ import Validation from "./validation.js";
 const id = "https://json-schema.org/keyword/propertyDependencies";
 const experimental = true;
 
-const compile = async (schema, ast) => {
+const compile = (schema, ast) => {
   return Pact.pipeline([
     Schema.entries,
     Pact.reduce(async (propertyDependencies, [propertyName, valueMappings]) => {

package/lib/keywords/requireAllExcept.js

@@ -18,7 +18,7 @@ const compile = async (schema, ast, parentSchema) => {
 };
 
 const interpret = (required, instance) => {
-  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Instance.value(instance).hasOwnProperty(propertyName));
+  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
 };
 
 export default { id, experimental, compile, interpret };

package/lib/keywords/required.js

@@ -7,7 +7,7 @@ const id = "https://json-schema.org/keyword/required";
 const compile = (schema) => Schema.value(schema);
 
 const interpret = (required, instance) => {
-  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.prototype.hasOwnProperty.call(Instance.value(instance), propertyName));
+  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
 };
 
 export default { id, compile, interpret };

package/lib/keywords/then.js

@@ -23,10 +23,9 @@ const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
 const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
   const nodes = ast[url][2];
 
-  return typeof nodes === "boolean" ? nodes : nodes
-    .every(([keywordId, , keywordValue]) => {
-      return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
-    });
+  return typeof nodes === "boolean" ? nodes : nodes.every(([keywordId, , keywordValue]) => {
+    return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+  });
 };
 
 const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchors) => {

package/lib/keywords/unevaluatedProperties.js

@@ -21,7 +21,7 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
     .every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors));
 };
 
-const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) =>{
+const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
   return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 };
 

package/lib/keywords/validation.js

@@ -3,7 +3,7 @@ import { publishAsync, publish } from "../pubsub.js";
 import { isExperimentalKeywordEnabled } from "../configuration.js";
 import * as Instance from "../instance.js";
 import { getKeywordId, getKeyword } from "../keywords.js";
-import { resolveUrl } from "../common.js";
+import { toAbsoluteUri } from "../common.js";
 import * as Schema from "../schema.js";
 
 
@@ -60,24 +60,23 @@ const compile = async (schema, ast) => {
 const interpret = (url, instance, ast, dynamicAnchors) => {
   const [keywordId, schemaUrl, nodes] = ast[url];
 
-  dynamicAnchors = { ...ast.metaData[resolveUrl("", url)].dynamicAnchors, ...dynamicAnchors };
+  dynamicAnchors = { ...ast.metaData[toAbsoluteUri(url)].dynamicAnchors, ...dynamicAnchors };
 
   publish("result.start");
-  const isValid = typeof nodes === "boolean" ? nodes : nodes
-    .every(([keywordId, schemaUrl, keywordValue]) => {
-      publish("result.start");
-      const isValid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
-
-      publish("result", {
-        keyword: keywordId,
-        absoluteKeywordLocation: schemaUrl,
-        instanceLocation: Instance.uri(instance),
-        valid: isValid,
-        ast: keywordValue
-      });
-      publish("result.end");
-      return isValid;
+  const isValid = typeof nodes === "boolean" ? nodes : nodes.every(([keywordId, schemaUrl, keywordValue]) => {
+    publish("result.start");
+    const isValid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+
+    publish("result", {
+      keyword: keywordId,
+      absoluteKeywordLocation: schemaUrl,
+      instanceLocation: Instance.uri(instance),
+      valid: isValid,
+      ast: keywordValue
     });
+    publish("result.end");
+    return isValid;
+  });
 
   publish("result", {
     keyword: keywordId,

package/lib/keywords.js

@@ -6,8 +6,12 @@ export const getKeyword = (id) => _keywords[id] || id.startsWith("https://json-s
 
 export const addKeyword = (keywordHandler) => {
   _keywords[keywordHandler.id] = {
-    collectEvaluatedItems: (keywordValue, instance, ast, dynamicAnchors, isTop) => keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && new Set(),
-    collectEvaluatedProperties: (keywordValue, instance, ast, dynamicAnchors, isTop) => keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && [],
+    collectEvaluatedItems: (keywordValue, instance, ast, dynamicAnchors, isTop) => {
+      return keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && new Set();
+    },
+    collectEvaluatedProperties: (keywordValue, instance, ast, dynamicAnchors, isTop) => {
+      return keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && [];
+    },
     ...keywordHandler
   };
 };

package/lib/pubsub.js

@@ -37,6 +37,4 @@ export const publishAsync = async (message, data) => {
   }
 
   await Promise.all(promises);
-
-  return;
 };

package/lib/reference.js

@@ -1,7 +1,7 @@
 const $__value = Symbol("$__value");
 const $__href = Symbol("$__href");
 
-export const cons = (href, value) => Object.freeze({
+export const cons = (href, value) => ({
   [$__href]: href,
   [$__value]: value
 });

package/lib/schema.d.ts

@@ -1,7 +1,7 @@
 import type { JsonType } from "./common.js";
 
 
-export const add: <A extends SchemaObject | boolean>(schema: A, url?: string, defaultSchemaVersion?: string) => string;
+export const add: <A extends SchemaObject | boolean>(schema: A, retrievalUri?: string, defaultSchemaVersion?: string) => string;
 export const get: (url: string, context?: SchemaDocument) => Promise<SchemaDocument>;
 export const markValidated: (id: string) => void;
 export const uri: (doc: SchemaDocument) => string;

package/lib/schema.js

@@ -2,7 +2,7 @@ import curry from "just-curry-it";
 import * as Pact from "@hyperjump/pact";
 import * as Json from "@hyperjump/json";
 import * as JsonPointer from "@hyperjump/json-pointer";
-import { jsonTypeOf, resolveUrl, urlFragment, pathRelative } from "./common.js";
+import { jsonTypeOf, resolveUri, toAbsoluteUri, uriFragment, pathRelative } from "./common.js";
 import fetch from "./fetch.js";
 import * as Keywords from "./keywords.js";
 import * as MediaTypes from "./media-types.js";
@@ -15,11 +15,11 @@ const schemaStoreAlias = {};
 
 const defaultDialectId = "https://json-schema.org/validation";
 
-export const add = (schema, url = undefined, contextDialectId = undefined) => {
+export const add = (schema, retrievalUri = undefined, contextDialectId = undefined) => {
   schema = JSON.parse(JSON.stringify(schema));
 
   // Dialect / JSON Schema Version
-  const dialectId = resolveUrl("", schema.$schema || contextDialectId || defaultDialectId);
+  const dialectId = toAbsoluteUri(schema.$schema || contextDialectId || defaultDialectId);
   delete schema.$schema;
 
   if (!Keywords.hasDialect(dialectId)) {
@@ -29,11 +29,14 @@ export const add = (schema, url = undefined, contextDialectId = undefined) => {
   // Identifiers
   const idToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/id")
     || Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
-  const internalUrl = resolveUrl(schema[idToken] || url, url);
-  const id = resolveUrl("", internalUrl);
+  if (retrievalUri === undefined && !(idToken in schema)) {
+    throw Error(`Unable to determine an identifier for the schema. Use the '${idToken}' keyword or pass a retrievalUri when loading the schema.`);
+  }
+  const internalUrl = resolveUri(schema[idToken] || retrievalUri, retrievalUri);
+  const id = toAbsoluteUri(internalUrl);
   delete schema[idToken];
-  if (url) {
-    const externalId = resolveUrl("", url);
+  if (retrievalUri) {
+    const externalId = toAbsoluteUri(retrievalUri);
     schemaStoreAlias[externalId] = id;
   }
 
@@ -80,7 +83,7 @@ const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors)
         anchors[anchor] = pointer;
       } else {
         delete subject[legacyIdToken].$schema;
-        subject[legacyIdToken] = resolveUrl(subject[legacyIdToken], id);
+        subject[legacyIdToken] = resolveUri(subject[legacyIdToken], id);
         add(subject, undefined, dialectId);
         return Reference.cons(subject[legacyIdToken], subject);
       }
@@ -88,10 +91,10 @@ const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors)
     }
 
     // Embedded Schema
-    const embeddedDialectId = typeof subject.$schema === "string" ? resolveUrl("", subject.$schema) : dialectId;
+    const embeddedDialectId = typeof subject.$schema === "string" ? toAbsoluteUri(subject.$schema) : dialectId;
     const idToken = Keywords.getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/id");
     if (typeof subject[idToken] === "string") {
-      subject[idToken] = resolveUrl(subject[idToken], id);
+      subject[idToken] = resolveUri(subject[idToken], id);
       add(subject, undefined, dialectId);
       return Reference.cons(subject[idToken], subject);
     }
@@ -142,7 +145,7 @@ export const markValidated = (id) => {
 };
 
 // Schema Retrieval
-const nil = Object.freeze({
+const nil = {
   id: undefined,
   dialectId: undefined,
   pointer: JsonPointer.nil,
@@ -151,12 +154,12 @@ const nil = Object.freeze({
   anchors: {},
   dynamicAnchors: {},
   validated: true
-});
+};
 
 export const get = async (url, contextDoc = nil) => {
-  const resolvedUrl = resolveUrl(url, uri(contextDoc));
-  const id = resolveUrl("", resolvedUrl);
-  const fragment = urlFragment(resolvedUrl);
+  const resolvedUrl = resolveUri(url, contextDoc.id);
+  const id = toAbsoluteUri(resolvedUrl);
+  const fragment = uriFragment(resolvedUrl);
 
   if (!hasStoredSchema(id)) {
     const response = await fetch(id, { headers: { Accept: "application/schema+json" } });
@@ -168,7 +171,7 @@ export const get = async (url, contextDoc = nil) => {
     const [schema, contextDialectId] = await MediaTypes.parse(response);
 
     // Try to determine the dialect from the meta-schema if it isn't already known
-    const dialectId = resolveUrl("", schema.$schema || contextDialectId || defaultDialectId);
+    const dialectId = toAbsoluteUri(schema.$schema || contextDialectId || defaultDialectId);
     if (!Keywords.hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
       await get(dialectId);
     }
@@ -177,12 +180,12 @@ export const get = async (url, contextDoc = nil) => {
   }
 
   const storedSchema = getStoredSchema(id);
-  const pointer = fragment[0] !== "/" ? getAnchorPointer(storedSchema, fragment) : fragment;
-  const doc = Object.freeze({
+  const pointer = fragment[0] === "/" ? fragment : getAnchorPointer(storedSchema, fragment);
+  const doc = {
     ...storedSchema,
     pointer: pointer,
     value: JsonPointer.get(pointer, storedSchema.schema)
-  });
+  };
 
   return followReferences(doc);
 };
@@ -205,13 +208,12 @@ export const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
 
 export const step = (key, doc) => {
   const storedSchema = getStoredSchema(doc.id);
-  const nextDoc = Object.freeze({
+  return followReferences({
     ...doc,
     pointer: JsonPointer.append(`${key}`, doc.pointer),
     value: value(doc)[key],
     validated: storedSchema.validated
   });
-  return followReferences(nextDoc);
 };
 
 export const keys = (doc) => Object.keys(value(doc));
@@ -254,16 +256,14 @@ export const toSchema = (schemaDoc, options = {}) => {
 
   const dynamicAnchors = {};
   for (const anchor in schemaDoc.dynamicAnchors) {
-    const pointer = urlFragment(schemaDoc.dynamicAnchors[anchor]);
+    const pointer = uriFragment(schemaDoc.dynamicAnchors[anchor]);
     dynamicAnchors[pointer] = anchor;
   }
 
   const schema = JSON.parse(Json.stringify(schemaDoc.schema, (key, value, pointer) => {
     if (Reference.isReference(value)) {
       const refValue = Reference.value(value);
-      if (!fullOptions.includeEmbedded && idToken in refValue) {
-        return;
-      } else {
+      if (fullOptions.includeEmbedded || !(idToken in refValue)) {
         return Reference.value(value);
       }
     } else {
@@ -292,8 +292,8 @@ export const toSchema = (schemaDoc, options = {}) => {
   const id = relativeUri(fullOptions.parentId, schemaDoc.id);
   const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
   return {
-    ...(id && { [idToken]: id }),
-    ...(dialect && { $schema: dialect }),
+    ...id && { [idToken]: id },
+    ...dialect && { $schema: dialect },
     ...schema
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -22,8 +22,8 @@
   },
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
-    "lint": "eslint lib",
-    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'oas-*/**/*.spec.ts'"
+    "lint": "eslint lib stable draft-* openapi-*",
+    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts'"
   },
   "repository": "github:hyperjump-io/json-schema",
   "keywords": [
@@ -64,6 +64,7 @@
     "@hyperjump/json": "^0.1.0",
     "@hyperjump/json-pointer": "^0.9.5",
     "@hyperjump/pact": "^0.2.4",
+    "@hyperjump/uri": "^1.0.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",
     "node-fetch": "^3.3.0"