@apidevtools/json-schema-ref-parser 9.0.5 → 9.0.9

package/CHANGELOG.md

@@ -1,9 +1,7 @@
 Change Log
-====================================================================================================
-All notable changes will be documented in this file.
-JSON Schema $Ref Parser adheres to [Semantic Versioning](http://semver.org/).
-
+==========
 
+See [GitHub Releases](https://github.com/APIDevTools/json-schema-ref-parser/releases) for more information on newer releases.
 
 [v9.0.0](https://github.com/APIDevTools/json-schema-ref-parser/tree/v9.0.0) (2020-04-21)
 ----------------------------------------------------------------------------------------------------

package/README.md

@@ -52,7 +52,7 @@ JSON Schema $Ref Parser is a full [JSON Reference](https://tools.ietf.org/html/d
 - Can [dereference](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback) your schema, producing a plain-old JavaScript object that's easy to work with
 - Supports [circular references](https://apitools.dev/json-schema-ref-parser/docs/#circular-refs), nested references, back-references, and cross-references between files
 - Maintains object reference equality — `$ref` pointers to the same value always resolve to the same object instance
-- Tested in Node and all major web browsers on Windows, Mac, and Linux
+- Tested in Node v10, v12, & v14, and all major web browsers on Windows, Mac, and Linux
 
 
 Example
@@ -129,7 +129,7 @@ Full API documentation is available [right here](https://apitools.dev/json-schem
 
 Contributing
 --------------------------
-I welcome any contributions, enhancements, and bug-fixes.  [File an issue](https://github.com/APIDevTools/json-schema-ref-parser/issues) on GitHub and [submit a pull request](https://github.com/APIDevTools/json-schema-ref-parser/pulls).
+I welcome any contributions, enhancements, and bug-fixes.  [Open an issue](https://github.com/APIDevTools/json-schema-ref-parser/issues) on GitHub and [submit a pull request](https://github.com/APIDevTools/json-schema-ref-parser/pulls).
 
 #### Building/Testing
 To build/test the project locally on your computer:
@@ -157,6 +157,6 @@ Big Thanks To
 --------------------------
 Thanks to these awesome companies for their support of Open Source developers ❤
 
-[![Travis CI](https://jstools.dev/img/badges/travis-ci.svg)](https://travis-ci.com)
+[![Stoplight](https://svgshare.com/i/TK5.svg)](https://stoplight.io/?utm_source=github&utm_medium=readme&utm_campaign=json_schema_ref_parser)
 [![SauceLabs](https://jstools.dev/img/badges/sauce-labs.svg)](https://saucelabs.com)
 [![Coveralls](https://jstools.dev/img/badges/coveralls.svg)](https://coveralls.io)

package/lib/dereference.js

@@ -16,7 +16,7 @@ module.exports = dereference;
  */
 function dereference (parser, options) {
   // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
-  let dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", [], parser.$refs, options);
+  let dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", new Set(), new Set(), new Map(), parser.$refs, options);
   parser.$refs.circular = dereferenced.circular;
   parser.schema = dereferenced.value;
 }
@@ -27,55 +27,66 @@ function dereference (parser, options) {
  * @param {*} obj - The value to crawl. If it's not an object or array, it will be ignored.
  * @param {string} path - The full path of `obj`, possibly with a JSON Pointer in the hash
  * @param {string} pathFromRoot - The path of `obj` from the schema root
- * @param {object[]} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} processedObjects - An array of all the objects that have already been processed
+ * @param {Map<string,object>} dereferencedCache - An map of all the dereferenced objects
  * @param {$Refs} $refs
  * @param {$RefParserOptions} options
  * @returns {{value: object, circular: boolean}}
  */
-function crawl (obj, path, pathFromRoot, parents, $refs, options) {
+function crawl (obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options) {
   let dereferenced;
   let result = {
     value: obj,
     circular: false
   };
 
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
-    parents.push(obj);
+  if (options.dereference.circular === "ignore" || !processedObjects.has(obj)) {
+    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+      parents.add(obj);
+      processedObjects.add(obj);
 
-    if ($Ref.isAllowed$Ref(obj, options)) {
-      dereferenced = dereference$Ref(obj, path, pathFromRoot, parents, $refs, options);
-      result.circular = dereferenced.circular;
-      result.value = dereferenced.value;
-    }
-    else {
-      for (let key of Object.keys(obj)) {
-        let keyPath = Pointer.join(path, key);
-        let keyPathFromRoot = Pointer.join(pathFromRoot, key);
-        let value = obj[key];
-        let circular = false;
-
-        if ($Ref.isAllowed$Ref(value, options)) {
-          dereferenced = dereference$Ref(value, keyPath, keyPathFromRoot, parents, $refs, options);
-          circular = dereferenced.circular;
-          obj[key] = dereferenced.value;
-        }
-        else {
-          if (parents.indexOf(value) === -1) {
-            dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, $refs, options);
+      if ($Ref.isAllowed$Ref(obj, options)) {
+        dereferenced = dereference$Ref(obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
+        result.circular = dereferenced.circular;
+        result.value = dereferenced.value;
+      }
+      else {
+        for (const key of Object.keys(obj)) {
+          let keyPath = Pointer.join(path, key);
+          let keyPathFromRoot = Pointer.join(pathFromRoot, key);
+          let value = obj[key];
+          let circular = false;
+
+          if ($Ref.isAllowed$Ref(value, options)) {
+            dereferenced = dereference$Ref(value, keyPath, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
             circular = dereferenced.circular;
-            obj[key] = dereferenced.value;
+            // Avoid pointless mutations; breaks frozen objects to no profit
+            if (obj[key] !== dereferenced.value) {
+              obj[key] = dereferenced.value;
+            }
           }
           else {
-            circular = foundCircularReference(keyPath, $refs, options);
+            if (!parents.has(value)) {
+              dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
+              circular = dereferenced.circular;
+              // Avoid pointless mutations; breaks frozen objects to no profit
+              if (obj[key] !== dereferenced.value) {
+                obj[key] = dereferenced.value;
+              }
+            }
+            else {
+              circular = foundCircularReference(keyPath, $refs, options);
+            }
           }
-        }
 
-        // Set the "isCircular" flag if this or any other property is circular
-        result.circular = result.circular || circular;
+          // Set the "isCircular" flag if this or any other property is circular
+          result.circular = result.circular || circular;
+        }
       }
-    }
 
-    parents.pop();
+      parents.delete(obj);
+    }
   }
 
   return result;
@@ -87,15 +98,38 @@ function crawl (obj, path, pathFromRoot, parents, $refs, options) {
  * @param {{$ref: string}} $ref - The JSON Reference to resolve
  * @param {string} path - The full path of `$ref`, possibly with a JSON Pointer in the hash
  * @param {string} pathFromRoot - The path of `$ref` from the schema root
- * @param {object[]} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} processedObjects - An array of all the objects that have already been dereferenced
+ * @param {Map<string,object>} dereferencedCache - An map of all the dereferenced objects
  * @param {$Refs} $refs
  * @param {$RefParserOptions} options
  * @returns {{value: object, circular: boolean}}
  */
-function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
+function dereference$Ref ($ref, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options) {
   // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
 
   let $refPath = url.resolve(path, $ref.$ref);
+
+  const cache = dereferencedCache.get($refPath);
+  if (cache) {
+    const refKeys = Object.keys($ref);
+    if (refKeys.length > 1) {
+      const extraKeys = {};
+      for (let key of refKeys) {
+        if (key !== "$ref" && !(key in cache.value)) {
+          extraKeys[key] = $ref[key];
+        }
+      }
+      return {
+        circular: cache.circular,
+        value: Object.assign({}, cache.value, extraKeys),
+      };
+    }
+
+    return cache;
+  }
+
+
   let pointer = $refs._resolve($refPath, path, options);
 
   if (pointer === null) {
@@ -107,7 +141,7 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
 
   // Check for circular references
   let directCircular = pointer.circular;
-  let circular = directCircular || parents.indexOf(pointer.value) !== -1;
+  let circular = directCircular || parents.has(pointer.value);
   circular && foundCircularReference(path, $refs, options);
 
   // Dereference the JSON reference
@@ -116,7 +150,7 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
   // Crawl the dereferenced value (unless it's circular)
   if (!circular) {
     // Determine if the dereferenced value is circular
-    let dereferenced = crawl(dereferencedValue, pointer.path, pathFromRoot, parents, $refs, options);
+    let dereferenced = crawl(dereferencedValue, pointer.path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
     circular = dereferenced.circular;
     dereferencedValue = dereferenced.value;
   }
@@ -132,10 +166,18 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
     dereferencedValue.$ref = pathFromRoot;
   }
 
-  return {
+
+  const dereferencedObject = {
     circular,
     value: dereferencedValue
   };
+
+  // only cache if no extra properties than $ref
+  if (Object.keys($ref).length === 1) {
+    dereferencedCache.set($refPath, dereferencedObject);
+  }
+
+  return dereferencedObject;
 }
 
 /**

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { JSONSchema4, JSONSchema4Type, JSONSchema6, JSONSchema6Type } from "json-schema";
+import { JSONSchema4, JSONSchema4Type, JSONSchema6, JSONSchema6Type, JSONSchema7, JSONSchema7Type } from "json-schema";
 
 export = $RefParser;
 
@@ -173,7 +173,7 @@ declare class $RefParser {
 // eslint-disable-next-line no-redeclare
 declare namespace $RefParser {
 
-  export type JSONSchema = JSONSchema4 | JSONSchema6;
+  export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
   export type SchemaCallback = (err: Error | null, schema?: JSONSchema) => any;
   export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 
@@ -208,7 +208,7 @@ declare namespace $RefParser {
       file?: Partial<ResolverOptions> | boolean;
       http?: HTTPResolverOptions | boolean;
     } & {
-      [key: string]: Partial<ResolverOptions>;
+      [key: string]: Partial<ResolverOptions> | HTTPResolverOptions | boolean | undefined;
     };
 
     /**
@@ -284,7 +284,7 @@ declare namespace $RefParser {
     read(
       file: FileInfo,
       callback?: (error: Error | null, data: string | null) => any
-    ): string | Buffer | Promise<string | Buffer>;
+    ): string | Buffer | JSONSchema | Promise<string | Buffer | JSONSchema>;
   }
 
   export interface ParserOptions {
@@ -395,7 +395,7 @@ declare namespace $RefParser {
      *
      * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
      */
-    public get($ref: string): JSONSchema4Type | JSONSchema6Type
+    public get($ref: string): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type
 
     /**
      * Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
@@ -403,12 +403,14 @@ declare namespace $RefParser {
      * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
      * @param value The value to assign. Can be anything (object, string, number, etc.)
      */
-    public set($ref: string, value: JSONSchema4Type | JSONSchema6Type): void
+    public set($ref: string, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void
   }
 
   export type JSONParserErrorType = "EUNKNOWN" | "EPARSER" | "EUNMATCHEDPARSER" | "ERESOLVER" | "EUNMATCHEDRESOLVER" | "EMISSINGPOINTER" | "EINVALIDPOINTER";
 
   export class JSONParserError extends Error {
+    public constructor(message: string, source: string);
+
     public readonly name: string;
     public readonly message: string;
     public readonly source: string;
@@ -439,28 +441,40 @@ declare namespace $RefParser {
   }
 
   export class ParserError extends JSONParserError {
+    public constructor(message: string, source: string);
+
     public readonly name = "ParserError";
     public readonly code = "EPARSER";
   }
   export class UnmatchedParserError extends JSONParserError {
+    public constructor(source: string);
+
     public readonly name = "UnmatchedParserError";
-    public readonly code ="EUNMATCHEDPARSER";
+    public readonly code = "EUNMATCHEDPARSER";
   }
   export class ResolverError extends JSONParserError {
+    public constructor(ex: Error | NodeJS.ErrnoException, source: string);
+
     public readonly name = "ResolverError";
-    public readonly code ="ERESOLVER";
+    public readonly code = "ERESOLVER";
     public readonly ioErrorCode?: string;
   }
   export class UnmatchedResolverError extends JSONParserError {
+    public constructor(source: string);
+
     public readonly name = "UnmatchedResolverError";
-    public readonly code ="EUNMATCHEDRESOLVER";
+    public readonly code = "EUNMATCHEDRESOLVER";
   }
   export class MissingPointerError extends JSONParserError {
+    public constructor(token: string | number, source: string);
+
     public readonly name = "MissingPointerError";
-    public readonly code ="EMISSINGPOINTER";
+    public readonly code = "EMISSINGPOINTER";
   }
   export class InvalidPointerError extends JSONParserError {
+    public constructor(pointer: string, source: string);
+
     public readonly name = "InvalidPointerError";
-    public readonly code ="EINVALIDPOINTER";
+    public readonly code = "EINVALIDPOINTER";
   }
 }

package/lib/parsers/yaml.js

@@ -45,7 +45,7 @@ module.exports = {
 
     if (typeof data === "string") {
       try {
-        return yaml.safeLoad(data);
+        return yaml.load(data);
       }
       catch (e) {
         throw new ParserError(e.message, file.url);

package/lib/pointer.js

@@ -64,6 +64,7 @@ function Pointer ($ref, path, friendlyPath) {
  *
  * @param {*} obj - The object that will be crawled
  * @param {$RefParserOptions} options
+ * @param {string} pathFromRoot - the path of place that initiated resolving
  *
  * @returns {Pointer}
  * Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
@@ -71,7 +72,7 @@ function Pointer ($ref, path, friendlyPath) {
  * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
  * of the resolved value.
  */
-Pointer.prototype.resolve = function (obj, options) {
+Pointer.prototype.resolve = function (obj, options, pathFromRoot) {
   let tokens = Pointer.parse(this.path, this.originalPath);
 
   // Crawl the object, one token at a time
@@ -83,6 +84,10 @@ Pointer.prototype.resolve = function (obj, options) {
       this.path = Pointer.join(this.path, tokens.slice(i));
     }
 
+    if (typeof this.value === "object" && this.value !== null && "$ref" in this.value) {
+      return this;
+    }
+
     let token = tokens[i];
     if (this.value[token] === undefined || this.value[token] === null) {
       this.value = null;
@@ -94,7 +99,10 @@ Pointer.prototype.resolve = function (obj, options) {
   }
 
   // Resolve the final value
-  resolveIf$Ref(this, options);
+  if (!this.value || this.value.$ref && url.resolve(this.path, this.value.$ref) !== pathFromRoot) {
+    resolveIf$Ref(this, options);
+  }
+
   return this;
 };
 
@@ -226,7 +234,11 @@ function resolveIf$Ref (pointer, options) {
       pointer.circular = true;
     }
     else {
-      let resolved = pointer.$ref.$refs._resolve($refPath, url.getHash(pointer.path), options);
+      let resolved = pointer.$ref.$refs._resolve($refPath, pointer.path, options);
+      if (resolved === null) {
+        return false;
+      }
+
       pointer.indirections += resolved.indirections + 1;
 
       if ($Ref.isExtended$Ref(pointer.value)) {

package/lib/ref.js

@@ -9,7 +9,7 @@ const { safePointerToPath, stripHash, getHash } = require("./util/url");
 /**
  * This class represents a single JSON reference and its resolved value.
  *
- * @constructor
+ * @class
  */
 function $Ref () {
   /**
@@ -27,24 +27,28 @@ function $Ref () {
   /**
    * The resolved value of the JSON reference.
    * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+   *
    * @type {?*}
    */
   this.value = undefined;
 
   /**
    * The {@link $Refs} object that contains this {@link $Ref} object.
+   *
    * @type {$Refs}
    */
   this.$refs = undefined;
 
   /**
    * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
+   *
    * @type {?string}
    */
   this.pathType = undefined;
 
   /**
    * List of all errors. Undefined if no errors.
+   *
    * @type {Array<JSONParserError | ResolverError | ParserError | MissingPointerError>}
    */
   this.errors = undefined;
@@ -53,7 +57,7 @@ function $Ref () {
 /**
  * Pushes an error to errors array.
  *
- * @param {Array<JSONParserError | JSONParserErrorGroup>} error - The error to be pushed
+ * @param {Array<JSONParserError | JSONParserErrorGroup>} err - The error to be pushed
  * @returns {void}
  */
 $Ref.prototype.addError = function (err) {
@@ -61,17 +65,22 @@ $Ref.prototype.addError = function (err) {
     this.errors = [];
   }
 
+  const existingErrors = this.errors.map(({ footprint }) => footprint);
+
   // the path has been almost certainly set at this point,
-  // but just in case something went wrong, let's inject path if necessary
+  // but just in case something went wrong, normalizeError injects path if necessary
+  // moreover, certain errors might point at the same spot, so filter them out to reduce noise
   if (Array.isArray(err.errors)) {
-    this.errors.push(...err.errors.map(normalizeError));
+    this.errors.push(...err.errors
+      .map(normalizeError)
+      .filter(({ footprint }) => !existingErrors.includes(footprint)),
+    );
   }
-  else {
+  else if (!existingErrors.includes(err.footprint)) {
     this.errors.push(normalizeError(err));
   }
 };
 
-
 /**
  * Determines whether the given JSON reference exists within this {@link $Ref#value}.
  *
@@ -106,13 +115,13 @@ $Ref.prototype.get = function (path, options) {
  * @param {string} path - The full path being resolved, optionally with a JSON pointer in the hash
  * @param {$RefParserOptions} options
  * @param {string} friendlyPath - The original user-specified path (used for error messages)
-*  @param {string} pathFromRoot - The path of `obj` from the schema root
- * @returns {Pointer}
+ *  @param {string} pathFromRoot - The path of `obj` from the schema root
+ * @returns {Pointer | null}
  */
 $Ref.prototype.resolve = function (path, options, friendlyPath, pathFromRoot) {
   let pointer = new Pointer(this, path, friendlyPath);
   try {
-    return pointer.resolve(this.value, options);
+    return pointer.resolve(this.value, options, pathFromRoot);
   }
   catch (err) {
     if (!options || !options.continueOnError || !isHandledError(err)) {

package/lib/resolve-external.js

@@ -44,6 +44,7 @@ function resolveExternal (parser, options) {
  * @param {string} path - The full path of `obj`, possibly with a JSON Pointer in the hash
  * @param {$Refs} $refs
  * @param {$RefParserOptions} options
+ * @param {Set} seen - Internal.
  *
  * @returns {Promise[]}
  * Returns an array of promises. There will be one promise for each JSON reference in `obj`.
@@ -51,10 +52,12 @@ function resolveExternal (parser, options) {
  * If any of the JSON references point to files that contain additional JSON references,
  * then the corresponding promise will internally reference an array of promises.
  */
-function crawl (obj, path, $refs, options) {
+function crawl (obj, path, $refs, options, seen) {
+  seen = seen || new Set();
   let promises = [];
 
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !seen.has(obj)) {
+    seen.add(obj); // Track previously seen objects to avoid infinite recursion
     if ($Ref.isExternal$Ref(obj)) {
       promises.push(resolve$Ref(obj, path, $refs, options));
     }
@@ -67,7 +70,7 @@ function crawl (obj, path, $refs, options) {
           promises.push(resolve$Ref(value, keyPath, $refs, options));
         }
         else {
-          promises = promises.concat(crawl(value, keyPath, $refs, options));
+          promises = promises.concat(crawl(value, keyPath, $refs, options, seen));
         }
       }
     }

package/lib/util/errors.js

@@ -15,6 +15,10 @@ const JSONParserError = exports.JSONParserError = class JSONParserError extends
 
     Ono.extend(this);
   }
+
+  get footprint () {
+    return `${this.path}+${this.source}+${this.code}+${this.message}`;
+  }
 };
 
 setErrorName(JSONParserError);

package/lib/util/url.js

@@ -69,11 +69,25 @@ exports.getProtocol = function getProtocol (path) {
 exports.getExtension = function getExtension (path) {
   let lastDot = path.lastIndexOf(".");
   if (lastDot >= 0) {
-    return path.substr(lastDot).toLowerCase();
+    return url.stripQuery(path.substr(lastDot).toLowerCase());
   }
   return "";
 };
 
+/**
+ * Removes the query, if any, from the given path.
+ *
+ * @param   {string} path
+ * @returns {string}
+ */
+exports.stripQuery = function stripQuery (path) {
+  let queryIndex = path.indexOf("?");
+  if (queryIndex >= 0) {
+    path = path.substr(0, queryIndex);
+  }
+  return path;
+};
+
 /**
  * Returns the hash (URL fragment), of the given path.
  * If there is no hash, then the root hash ("#") is returned.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "9.0.5",
+  "version": "9.0.9",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",
@@ -20,6 +20,10 @@
     {
       "name": "Boris Cherny",
       "email": "boris@performancejs.com"
+    },
+    {
+      "name": "Jakub Rożek",
+      "email": "jakub@stoplight.io"
     }
   ],
   "homepage": "https://apitools.dev/json-schema-ref-parser/",
@@ -37,6 +41,7 @@
     "lib"
   ],
   "scripts": {
+    "build": "cp LICENSE *.md dist",
     "clean": "shx rm -rf .nyc_output coverage",
     "lint": "eslint lib test/fixtures test/specs",
     "test": "npm run test:node && npm run test:typescript && npm run test:browser && npm run lint",
@@ -46,32 +51,63 @@
     "coverage": "npm run coverage:node && npm run coverage:browser",
     "coverage:node": "nyc node_modules/mocha/bin/mocha",
     "coverage:browser": "npm run test:browser -- --coverage",
-    "upgrade": "npm-check -u && npm audit fix",
-    "bump": "bump --tag --push --all",
-    "release": "npm run upgrade && npm run clean && npm test && npm run bump"
+    "upgrade": "npm-check -u && npm audit fix"
   },
   "devDependencies": {
-    "@babel/polyfill": "^7.10.4",
-    "@jsdevtools/eslint-config": "^1.0.5",
-    "@jsdevtools/host-environment": "^2.0.4",
+    "@amanda-mitchell/semantic-release-npm-multiple": "^2.5.0",
+    "@babel/polyfill": "^7.12.1",
+    "@jsdevtools/eslint-config": "^1.0.7",
+    "@jsdevtools/host-environment": "^2.1.2",
     "@jsdevtools/karma-config": "^3.1.7",
-    "@jsdevtools/version-bump-prompt": "^6.0.6",
-    "@types/json-schema": "^7.0.4",
-    "@types/node": "^14.0.23",
-    "chai": "^4.2.0",
+    "@types/node": "^14.14.21",
     "chai-subset": "^1.6.0",
-    "eslint": "^7.5.0",
-    "karma": "^5.0.2",
+    "chai": "^4.2.0",
+    "eslint": "^7.18.0",
     "karma-cli": "^2.0.0",
-    "mocha": "^8.0.1",
+    "karma": "^5.0.2",
+    "mocha": "^8.2.1",
     "npm-check": "^5.9.0",
     "nyc": "^15.0.1",
+    "semantic-release-plugin-update-version-in-files": "^1.1.0",
     "shx": "^0.3.2",
-    "typescript": "^3.9.7"
+    "typescript": "^4.0.5"
   },
   "dependencies": {
     "@jsdevtools/ono": "^7.1.3",
+    "@types/json-schema": "^7.0.6",
     "call-me-maybe": "^1.0.1",
-    "js-yaml": "^3.13.1"
+    "js-yaml": "^4.1.0"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "semantic-release-plugin-update-version-in-files",
+        {
+          "files": [
+            "dist/package.json"
+          ],
+          "placeholder": "X.X.X"
+        }
+      ],
+      [
+        "@amanda-mitchell/semantic-release-npm-multiple",
+        {
+          "registries": {
+            "scoped": {
+              "pkgRoot": "."
+            },
+            "unscoped": {
+              "pkgRoot": "dist"
+            }
+          }
+        }
+      ],
+      "@semantic-release/github"
+    ]
   }
 }