@hyperjump/json-schema 0.23.3 → 1.0.0

package/lib/keywords.js

@@ -0,0 +1,59 @@
+import metaData from "./keywords/meta-data.js";
+
+
+const _keywords = {};
+export const getKeyword = (id) => _keywords[id] || id.startsWith("https://json-schema.org/keyword/unknown#") && { id, ...metaData };
+
+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) && [],
+    ...keywordHandler
+  };
+};
+
+const _vocabularies = {};
+export const defineVocabulary = (id, keywords) => {
+  _vocabularies[id] = keywords;
+};
+
+const _dialects = {};
+const _allowUnknownKeywords = {};
+export const getKeywordId = (dialectId, keyword) => _dialects[dialectId]?.[keyword]
+  || _allowUnknownKeywords[dialectId] && `https://json-schema.org/keyword/unknown#${keyword}`;
+export const getKeywordName = (dialectId, keywordId) => {
+  for (const keyword in _dialects[dialectId]) {
+    if (_dialects[dialectId][keyword] === keywordId) {
+      return keyword;
+    }
+  }
+};
+
+export const hasDialect = (dialectId) => dialectId in _dialects;
+
+export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false) => {
+  _allowUnknownKeywords[dialectId] = allowUnknownKeywords;
+
+  _dialects[dialectId] = {};
+  Object.entries(dialect)
+    .forEach(([vocabularyId, isRequired]) => {
+      if (vocabularyId in _vocabularies) {
+        Object.entries(_vocabularies[vocabularyId])
+          .forEach(([keyword, keywordId]) => {
+            if (!(keywordId in _keywords)) {
+              if (isRequired) {
+                delete _dialects[dialectId];
+                throw Error(`The '${keywordId}' keyword is not supported. This keyword was included in the '${vocabularyId}' vocabulary which is required by the '${dialectId}' dialect.`);
+              } else {
+                // Allow keyword to be ignored
+                keywordId = `https://json-schema.org/keyword/unknown#${keyword}`;
+              }
+            }
+            _dialects[dialectId][keyword] = keywordId;
+          });
+      } else {
+        delete _dialects[dialectId];
+        throw Error(`Unrecognized vocabulary: ${vocabularyId}. You can define this vocabulary with the 'defineVocabulary' function.`);
+      }
+    });
+};

package/lib/media-types.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from "./schema.js";
+
+
+export const addMediaTypePlugin: (contentType: string, plugin: MediaTypePlugin) => void;
+
+export type MediaTypePlugin = {
+  parse: (response: Response, mediaTypeParameters: { [parameter: string]: string }) => Promise<[SchemaObject, string | undefined]>;
+  matcher: (path: string) => boolean;
+};

package/lib/media-types.js

@@ -0,0 +1,26 @@
+import contentTypeParser from "content-type";
+
+
+const mediaTypePlugins = {};
+
+export const addMediaTypePlugin = (contentType, plugin) => {
+  mediaTypePlugins[contentType] = plugin;
+};
+
+export const parse = (response) => {
+  const contentType = contentTypeParser.parse(response.headers.get("content-type"));
+  if (!(contentType.type in mediaTypePlugins)) {
+    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);
+  }
+  return mediaTypePlugins[contentType.type].parse(response, contentType.parameters);
+};
+
+export const getContentType = (path) => {
+  for (const contentType in mediaTypePlugins) {
+    if (mediaTypePlugins[contentType].matcher(path)) {
+      return contentType;
+    }
+  }
+
+  return "application/octet-stream";
+};

package/lib/pubsub.js

@@ -0,0 +1,42 @@
+const subscriptions = {};
+let uid = 0;
+
+export const subscribe = (message, fn) => {
+  if (!(message in subscriptions)) {
+    subscriptions[message] = {};
+  }
+
+  const subscriptionId = `pubsub_subscription_${uid++}`;
+  subscriptions[message][subscriptionId] = fn;
+
+  return subscriptionId;
+};
+
+export const unsubscribe = (message, token) => {
+  delete subscriptions[message][token];
+};
+
+export const publish = (message, data) => {
+  for (const subscribedMessage in subscriptions) {
+    if (subscribedMessage === message || message.startsWith(`${subscribedMessage}.`)) {
+      for (const subscriptionId in subscriptions[subscribedMessage]) {
+        subscriptions[subscribedMessage][subscriptionId](message, data);
+      }
+    }
+  }
+};
+
+export const publishAsync = async (message, data) => {
+  const promises = [];
+  for (const subscribedMessage in subscriptions) {
+    if (subscribedMessage === message || message.startsWith(`${subscribedMessage}.`)) {
+      for (const subscriptionId in subscriptions[subscribedMessage]) {
+        promises.push(subscriptions[message][subscriptionId](message, data));
+      }
+    }
+  }
+
+  await Promise.all(promises);
+
+  return;
+};

package/lib/reference.d.ts

@@ -0,0 +1,11 @@
+export const cons: (href: string, value: unknown) => Ref;
+export const isReference: (ref: unknown) => ref is Ref;
+export const href: (ref: Ref) => string;
+export const value: <A>(ref: Ref) => A;
+
+declare const $__value: unique symbol;
+declare const $__href: unique symbol;
+export type Ref = {
+  [$__href]: string;
+  [$__value]: unknown;
+};

package/lib/reference.js

@@ -0,0 +1,11 @@
+const $__value = Symbol("$__value");
+const $__href = Symbol("$__href");
+
+export const cons = (href, value) => Object.freeze({
+  [$__href]: href,
+  [$__value]: value
+});
+
+export const isReference = (ref) => ref && ref[$__href] !== undefined;
+export const href = (ref) => ref[$__href];
+export const value = (ref) => ref[$__value];

package/lib/schema.d.ts

@@ -0,0 +1,64 @@
+import type { JsonType } from "./common.js";
+
+
+export const add: <A extends SchemaObject | boolean>(schema: A, url?: 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;
+export const value: <A extends SchemaFragment>(doc: SchemaDocument<A>) => A;
+export const typeOf: (
+  (doc: SchemaDocument, type: "null") => doc is SchemaDocument<null>
+) & (
+  (doc: SchemaDocument, type: "boolean") => doc is SchemaDocument<boolean>
+) & (
+  (doc: SchemaDocument, type: "object") => doc is SchemaDocument<SchemaObject>
+) & (
+  (doc: SchemaDocument, type: "array") => doc is SchemaDocument<SchemaFragment[]>
+) & (
+  (doc: SchemaDocument, type: "number" | "integer") => doc is SchemaDocument<number>
+) & (
+  (doc: SchemaDocument, type: "string") => doc is SchemaDocument<string>
+) & (
+  (doc: SchemaDocument, type: JsonType) => boolean
+) & (
+  (doc: SchemaDocument) => (type: JsonType) => boolean
+);
+export const has: (key: string, doc: SchemaDocument) => boolean;
+export const step: (key: string, doc: SchemaDocument) => Promise<SchemaDocument>;
+export const keys: (doc: SchemaDocument) => string[];
+export const entries: (doc: SchemaDocument) => Promise<SchemaEntry[]>;
+export const map: (
+  <A>(fn: MapFn<Promise<A> | A>, doc: SchemaDocument) => Promise<A[]>
+) & (
+  <A>(fn: MapFn<Promise<A> | A>) => (doc: SchemaDocument) => Promise<A[]>
+);
+export const length: (doc: SchemaDocument) => number;
+export const toSchema: (doc: SchemaDocument, options: ToSchemaOptions) => SchemaObject;
+
+type MapFn<A> = (element: SchemaDocument, index: number) => A;
+export type SchemaEntry = [string, SchemaDocument];
+
+export type ToSchemaOptions = {
+  parentId?: string;
+  parentDialect?: string;
+  includeEmbedded?: boolean;
+};
+
+export type SchemaDocument<A extends SchemaFragment = SchemaFragment> = {
+  id: string;
+  dialectId: string;
+  pointer: string;
+  schema: SchemaObject;
+  value: A;
+  anchors: Anchors;
+  dynamicAnchors: Anchors;
+  vocabulary: Record<string, boolean>;
+  validated: boolean;
+};
+
+export type SchemaFragment = string | number | boolean | null | SchemaObject | SchemaFragment[];
+export type SchemaObject = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+  [keyword: string]: SchemaFragment;
+};
+
+export type Anchors = Record<string, string>;

package/lib/schema.js

@@ -0,0 +1,308 @@
+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 fetch from "./fetch.js";
+import * as Keywords from "./keywords.js";
+import * as MediaTypes from "./media-types.js";
+import * as Reference from "./reference.js";
+
+
+// Schema Management
+const schemaStore = {};
+const schemaStoreAlias = {};
+
+const defaultDialectId = "https://json-schema.org/validation";
+
+export const add = (schema, url = undefined, contextDialectId = undefined) => {
+  schema = JSON.parse(JSON.stringify(schema));
+
+  // Dialect / JSON Schema Version
+  const dialectId = resolveUrl("", schema.$schema || contextDialectId || defaultDialectId);
+  delete schema.$schema;
+
+  if (!Keywords.hasDialect(dialectId)) {
+    throw Error(`Encountered unknown dialect '${dialectId}'`);
+  }
+
+  // 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);
+  delete schema[idToken];
+  if (url) {
+    const externalId = resolveUrl("", url);
+    schemaStoreAlias[externalId] = id;
+  }
+
+  // Vocabulary
+  const vocabularyToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/vocabulary");
+  if (jsonTypeOf(schema[vocabularyToken], "object")) {
+    const allowUnknownKeywords = schema[vocabularyToken]["https://json-schema.org/draft/2019-09/vocab/core"]
+      || schema[vocabularyToken]["https://json-schema.org/draft/2020-12/vocab/core"];
+
+    Keywords.loadDialect(id, schema[vocabularyToken], allowUnknownKeywords);
+    delete schema[vocabularyToken];
+  }
+
+  const dynamicAnchors = {};
+
+  // Recursive anchor
+  const recursiveAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor");
+  if (schema[recursiveAnchorToken] === true) {
+    dynamicAnchors[""] = `${id}#`;
+  }
+  delete schema[recursiveAnchorToken];
+
+  // Store Schema
+  const anchors = { "": "" };
+  schemaStore[id] = {
+    id: id,
+    dialectId: dialectId,
+    schema: processSchema(schema, id, dialectId, JsonPointer.nil, anchors, dynamicAnchors),
+    anchors: anchors,
+    dynamicAnchors: dynamicAnchors,
+    validated: false
+  };
+
+  return id;
+};
+
+const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
+  if (jsonTypeOf(subject, "object")) {
+    // Legacy id
+    const legacyIdToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
+    if (typeof subject[legacyIdToken] === "string") {
+      if (subject[legacyIdToken][0] === "#") {
+        const anchor = decodeURIComponent(subject[legacyIdToken].slice(1));
+        anchors[anchor] = pointer;
+      } else {
+        delete subject[legacyIdToken].$schema;
+        subject[legacyIdToken] = resolveUrl(subject[legacyIdToken], id);
+        add(subject, undefined, dialectId);
+        return Reference.cons(subject[legacyIdToken], subject);
+      }
+      delete subject[legacyIdToken];
+    }
+
+    // Embedded Schema
+    const embeddedDialectId = typeof subject.$schema === "string" ? resolveUrl("", 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);
+      add(subject, undefined, dialectId);
+      return Reference.cons(subject[idToken], subject);
+    }
+
+    // Legacy dynamic anchor
+    const legacyDynamicAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+    if (typeof subject[legacyDynamicAnchorToken] === "string") {
+      dynamicAnchors[subject[legacyDynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
+      anchors[subject[legacyDynamicAnchorToken]] = pointer;
+      delete subject[legacyDynamicAnchorToken];
+    }
+
+    const dynamicAnchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+    if (typeof subject[dynamicAnchorToken] === "string") {
+      dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
+      delete subject[dynamicAnchorToken];
+    }
+
+    const anchorToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/anchor");
+    if (typeof subject[anchorToken] === "string") {
+      anchors[subject[anchorToken]] = pointer;
+      delete subject[anchorToken];
+    }
+
+    // Legacy $ref
+    const jrefToken = Keywords.getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/ref");
+    if (typeof subject[jrefToken] === "string") {
+      return Reference.cons(subject[jrefToken], subject);
+    }
+
+    for (const key in subject) {
+      subject[key] = processSchema(subject[key], id, dialectId, JsonPointer.append(key, pointer), anchors, dynamicAnchors);
+    }
+  } else if (Array.isArray(subject)) {
+    for (let index = 0; index < subject.length; index++) {
+      subject[index] = processSchema(subject[index], id, dialectId, JsonPointer.append(index, pointer), anchors, dynamicAnchors);
+    }
+  }
+
+  return subject;
+};
+
+const hasStoredSchema = (id) => id in schemaStore || id in schemaStoreAlias;
+const getStoredSchema = (id) => schemaStore[schemaStoreAlias[id]] || schemaStore[id];
+
+export const markValidated = (id) => {
+  schemaStore[id].validated = true;
+};
+
+// Schema Retrieval
+const nil = Object.freeze({
+  id: undefined,
+  dialectId: undefined,
+  pointer: JsonPointer.nil,
+  schema: undefined,
+  value: undefined,
+  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);
+
+  if (!hasStoredSchema(id)) {
+    const response = await fetch(id, { headers: { Accept: "application/schema+json" } });
+    if (response.status >= 400) {
+      await response.text(); // Sometimes node hangs without this hack
+      throw Error(`Failed to retrieve schema with id: ${id}`);
+    }
+
+    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);
+    if (!Keywords.hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
+      await get(dialectId);
+    }
+
+    add(schema, id, contextDialectId);
+  }
+
+  const storedSchema = getStoredSchema(id);
+  const pointer = fragment[0] !== "/" ? getAnchorPointer(storedSchema, fragment) : fragment;
+  const doc = Object.freeze({
+    ...storedSchema,
+    pointer: pointer,
+    value: JsonPointer.get(pointer, storedSchema.schema)
+  });
+
+  return followReferences(doc);
+};
+
+const followReferences = (doc) => Reference.isReference(doc.value) ? get(Reference.href(doc.value), doc) : doc;
+
+const getAnchorPointer = (schema, fragment) => {
+  if (!(fragment in schema.anchors)) {
+    throw Error(`No such anchor '${encodeURI(schema.id)}#${encodeURI(fragment)}'`);
+  }
+
+  return schema.anchors[fragment];
+};
+
+// Utility Functions
+export const uri = (doc) => doc.id ? `${doc.id}#${encodeURI(doc.pointer)}` : undefined;
+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 = (doc, type) => jsonTypeOf(value(doc), type);
+
+export const step = (key, doc) => {
+  const storedSchema = getStoredSchema(doc.id);
+  const nextDoc = Object.freeze({
+    ...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));
+
+export const entries = (doc) => Pact.pipeline([
+  value,
+  Object.keys,
+  Pact.map(async (key) => [key, await step(key, doc)]),
+  Pact.all
+], doc);
+
+export const map = curry((fn, doc) => Pact.pipeline([
+  value,
+  Pact.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
+  Pact.all
+], doc));
+
+export const length = (doc) => value(doc).length;
+
+const toSchemaDefaultOptions = {
+  parentId: "",
+  parentDialect: "",
+  includeEmbedded: true
+};
+export const toSchema = (schemaDoc, options = {}) => {
+  const fullOptions = { ...toSchemaDefaultOptions, ...options };
+
+  const idToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/id");
+  const anchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/anchor");
+  const dynamicAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+  const legacyDynamicAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+  const recursiveAnchorToken = Keywords.getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/recursiveAnchor");
+
+  const anchors = {};
+  for (const anchor in schemaDoc.anchors) {
+    if (anchor !== "" && !schemaDoc.dynamicAnchors[anchor]) {
+      anchors[schemaDoc.anchors[anchor]] = anchor;
+    }
+  }
+
+  const dynamicAnchors = {};
+  for (const anchor in schemaDoc.dynamicAnchors) {
+    const pointer = urlFragment(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 {
+        return Reference.value(value);
+      }
+    } else {
+      if (pointer in anchors) {
+        value = { [anchorToken]: anchors[pointer], ...value };
+      }
+      if (pointer in dynamicAnchors) {
+        if (dynamicAnchorToken) {
+          value = { [dynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+        }
+
+        // Legacy dynamic anchor
+        if (legacyDynamicAnchorToken) {
+          value = { [legacyDynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+        }
+
+        // Recursive anchor
+        if (recursiveAnchorToken) {
+          value = { [recursiveAnchorToken]: true, ...value };
+        }
+      }
+      return value;
+    }
+  }));
+
+  const id = relativeUri(fullOptions.parentId, schemaDoc.id);
+  const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
+  return {
+    ...(id && { [idToken]: id }),
+    ...(dialect && { $schema: dialect }),
+    ...schema
+  };
+};
+
+const relativeUri = (from, to) => {
+  if (to.startsWith("file://")) {
+    const pathToSchema = from.slice(7, from.lastIndexOf("/"));
+    return from === "" ? "" : pathRelative(pathToSchema, to.slice(7));
+  } else {
+    return to;
+  }
+};

package/package.json

@@ -1,28 +1,36 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "0.23.3",
-  "description": "A JSON Schema Validator",
-  "main": "lib/index.js",
+  "version": "1.0.0",
+  "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
+  "type": "module",
   "exports": {
-    "require": "./lib/index.js",
-    "import": "./lib/index.mjs"
+    ".": "./stable/index.js",
+    "./draft-04": "./draft-04/index.js",
+    "./draft-06": "./draft-06/index.js",
+    "./draft-07": "./draft-07/index.js",
+    "./draft-2019-09": "./draft-2019-09/index.js",
+    "./draft-2020-12": "./draft-2020-12/index.js",
+    "./experimental": "./lib/experimental.js",
+    "./schema/experimental": "./lib/schema.js",
+    "./instance/experimental": "./lib/instance.js"
+  },
+  "browser": {
+    "./lib/fetch.js": "./lib/fetch.browser.js"
   },
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
     "lint": "eslint lib",
-    "test": "mocha --require ts-node/register 'lib/**/*.spec.ts'",
-    "build": "rollup --config rollup.config.js",
-    "prepublishOnly": "npm run build",
-    "postinstall": "node -e \"require('fs').rmSync('dist', { recursive: true })\""
+    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts'"
   },
-  "repository": "github:hyperjump-io/json-schema-validator",
+  "repository": "github:hyperjump-io/json-schema",
   "keywords": [
     "JSON Schema",
-    "draft-04",
+    "JSON",
+    "Schema",
+    "2020-12",
+    "2019-09",
     "draft-06",
-    "draft-07",
-    "draft 2019-09",
-    "draft 2020-12",
+    "draft-04",
     "vocabulary",
     "vocabularies"
   ],
@@ -33,8 +41,6 @@
     "url": "https://github.com/sponsors/jdesrosiers"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "*",
-    "@rollup/plugin-node-resolve": "*",
     "@types/chai": "*",
     "@types/mocha": "*",
     "@typescript-eslint/eslint-plugin": "*",
@@ -46,14 +52,17 @@
     "eslint-plugin-import": "*",
     "json-schema-test-suite": "github:json-schema-org/JSON-Schema-Test-Suite",
     "mocha": "*",
-    "rimraf": "*",
-    "rollup": "*",
-    "rollup-plugin-terser": "*",
+    "nock": "*",
     "ts-node": "*",
-    "typescript": "*"
+    "typescript": "*",
+    "yaml": "*"
   },
   "dependencies": {
-    "@hyperjump/json-schema-core": "^0.28.0",
-    "fastest-stable-stringify": "^2.0.2"
+    "@hyperjump/json": "^0.1.0",
+    "@hyperjump/json-pointer": "^0.9.5",
+    "@hyperjump/pact": "^0.2.4",
+    "content-type": "^1.0.4",
+    "fastest-stable-stringify": "^2.0.2",
+    "node-fetch": "^3.3.0"
   }
 }