@apidevtools/json-schema-ref-parser 9.0.2 → 9.0.7

package/README.md

@@ -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:

package/lib/bundle.js

@@ -39,7 +39,7 @@ function bundle (parser, options) {
 function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs, options) {
   let obj = key === null ? parent : parent[key];
 
-  if (obj && typeof obj === "object") {
+  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     if ($Ref.isAllowed$Ref(obj)) {
       inventory$Ref(parent, key, path, pathFromRoot, indirections, inventory, $refs, options);
     }

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, "#", [], [], {}, parser.$refs, options);
   parser.$refs.circular = dereferenced.circular;
   parser.schema = dereferenced.value;
 }
@@ -28,54 +28,65 @@ function dereference (parser, options) {
  * @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 {object[]} processedObjects - An array of all the objects that have already been processed
+ * @param {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") {
-    parents.push(obj);
+  if (options.dereference.circular === "ignore" || processedObjects.indexOf(obj) === -1) {
+    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+      parents.push(obj);
+      processedObjects.push(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 (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, 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.indexOf(value) === -1) {
+              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.pop();
+    }
   }
 
   return result;
@@ -88,14 +99,38 @@ function crawl (obj, path, pathFromRoot, parents, $refs, options) {
  * @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 {object[]} processedObjects - An array of all the objects that have already been dereferenced
+ * @param {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);
+
+  if (dereferencedCache[$refPath]) {
+    const cache = dereferencedCache[$refPath];
+
+    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) {
@@ -116,7 +151,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 +167,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[$refPath] = dereferencedObject;
+  }
+
+  return dereferencedObject;
 }
 
 /**

package/lib/index.d.ts

@@ -1,6 +1,6 @@
-import { JSONSchema4, JSONSchema4Type, JSONSchema6, JSONSchema6Type } from 'json-schema';
+import { JSONSchema4, JSONSchema4Type, JSONSchema6, JSONSchema6Type } from "json-schema";
 
-export = $RefParser
+export = $RefParser;
 
 /**
  * This is the default export of JSON Schema $Ref Parser. You can creates instances of this class using new $RefParser(), or you can just call its static methods.
@@ -14,7 +14,7 @@ declare class $RefParser {
    *
    * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#schema
    */
-  schema: $RefParser.JSONSchema
+  public schema: $RefParser.JSONSchema;
 
   /**
    * The $refs property is a `$Refs` object, which lets you access all of the externally-referenced files in the schema, as well as easily get and set specific values in the schema using JSON pointers.
@@ -23,7 +23,7 @@ declare class $RefParser {
    *
    * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#refs
    */
-  $refs: $RefParser.$Refs
+  public $refs: $RefParser.$Refs;
 
   /**
    * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
@@ -36,12 +36,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the dereferenced schema object
    */
-  dereference(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  dereference(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public dereference(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public dereference(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
@@ -54,12 +54,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the dereferenced schema object
    */
-  static dereference(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  static dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static dereference(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  static dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  static dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static dereference(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public static dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static dereference(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public static dereference(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static dereference(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
@@ -72,12 +72,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the bundled schema object
    */
-  bundle(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  bundle(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public bundle(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public bundle(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
@@ -90,12 +90,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the bundled schema object
    */
-  static bundle(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  static bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static bundle(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  static bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  static bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static bundle(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public static bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static bundle(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public static bundle(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static bundle(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
@@ -108,12 +108,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the parsed schema object, or an error
    */
-  parse(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  parse(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public parse(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public parse(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
@@ -126,12 +126,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive the parsed schema object, or an error
    */
-  static parse(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
-  static parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
-  static parse(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
-  static parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
-  static parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static parse(schema: string | $RefParser.JSONSchema, callback: $RefParser.SchemaCallback): void;
+  public static parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.SchemaCallback): void;
+  public static parse(schema: string | $RefParser.JSONSchema): Promise<$RefParser.JSONSchema>;
+  public static parse(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
+  public static parse(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.JSONSchema>;
 
   /**
    * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
@@ -144,12 +144,12 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive a `$Refs` object
    */
-  resolve(schema: string | $RefParser.JSONSchema, callback: $RefParser.$RefsCallback): void;
-  resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
-  resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
-  resolve(schema: string | $RefParser.JSONSchema): Promise<$RefParser.$Refs>;
-  resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
-  resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
+  public resolve(schema: string | $RefParser.JSONSchema, callback: $RefParser.$RefsCallback): void;
+  public resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
+  public resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
+  public resolve(schema: string | $RefParser.JSONSchema): Promise<$RefParser.$Refs>;
+  public resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
+  public resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
 
   /**
    * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
@@ -162,14 +162,15 @@ declare class $RefParser {
    * @param options (optional)
    * @param callback (optional) A callback that will receive a `$Refs` object
    */
-  static resolve(schema: string | $RefParser.JSONSchema, callback: $RefParser.$RefsCallback): void;
-  static resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
-  static resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
-  static resolve(schema: string | $RefParser.JSONSchema): Promise<$RefParser.$Refs>;
-  static resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
-  static resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
+  public static resolve(schema: string | $RefParser.JSONSchema, callback: $RefParser.$RefsCallback): void;
+  public static resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
+  public static resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options, callback: $RefParser.$RefsCallback): void;
+  public static resolve(schema: string | $RefParser.JSONSchema): Promise<$RefParser.$Refs>;
+  public static resolve(schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
+  public static resolve(baseUrl: string, schema: string | $RefParser.JSONSchema, options: $RefParser.Options): Promise<$RefParser.$Refs>;
 }
 
+// eslint-disable-next-line no-redeclare
 declare namespace $RefParser {
 
   export type JSONSchema = JSONSchema4 | JSONSchema6;
@@ -179,7 +180,7 @@ declare namespace $RefParser {
   /**
    * See https://apitools.dev/json-schema-ref-parser/docs/options.html
    */
-  export type Options = {
+  export interface Options {
 
     /**
      * The `parse` options determine how different types of files will be parsed.
@@ -187,11 +188,11 @@ declare namespace $RefParser {
      * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
      */
     parse?: {
-      json?: ParserOptions | boolean
-      yaml?: ParserOptions | boolean
-      text?: (ParserOptions & { encoding?: string }) | boolean
-      [key: string]: ParserOptions | boolean | undefined
-    }
+      json?: ParserOptions | boolean;
+      yaml?: ParserOptions | boolean;
+      text?: (ParserOptions & { encoding?: string }) | boolean;
+      [key: string]: ParserOptions | boolean | undefined;
+    };
 
     /**
      * The `resolve` options control how JSON Schema $Ref Parser will resolve file paths and URLs, and how those files will be read/downloaded.
@@ -203,12 +204,12 @@ declare namespace $RefParser {
       /**
        * Determines whether external $ref pointers will be resolved. If this option is disabled, then external `$ref` pointers will simply be ignored.
        */
-      external?: boolean
-      file?: Partial<ResolverOptions> | boolean
-      http?: HTTPResolverOptions | boolean
+      external?: boolean;
+      file?: Partial<ResolverOptions> | boolean;
+      http?: HTTPResolverOptions | boolean;
     } & {
-      [key: string]: Partial<ResolverOptions>
-    }
+      [key: string]: Partial<ResolverOptions>;
+    };
 
     /**
      * By default, JSON Schema $Ref Parser throws the first error it encounters. Setting `continueOnError` to `true`
@@ -229,8 +230,8 @@ declare namespace $RefParser {
        *
        * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
        */
-      circular?: boolean | 'ignore'
-    }
+      circular?: boolean | "ignore";
+    };
   }
 
   export interface HTTPResolverOptions extends Partial<ResolverOptions> {
@@ -238,22 +239,22 @@ declare namespace $RefParser {
     /**
      * You can specify any HTTP headers that should be sent when downloading files. For example, some servers may require you to set the `Accept` or `Referrer` header.
      */
-    headers?: object
+    headers?: object;
 
     /**
      * The amount of time (in milliseconds) to wait for a response from the server when downloading files. The default is 5 seconds.
      */
-    timeout?: number
+    timeout?: number;
 
     /**
      * The maximum number of HTTP redirects to follow per file. The default is 5. To disable automatic following of redirects, set this to zero.
      */
-    redirects?: number
+    redirects?: number;
 
     /**
      * Set this to `true` if you're downloading files from a CORS-enabled server that requires authentication
      */
-    withCredentials?: boolean
+    withCredentials?: boolean;
   }
 
   /**
@@ -268,12 +269,12 @@ declare namespace $RefParser {
      *
      * The order property and canRead property are related to each other. For each file that JSON Schema $Ref Parser needs to resolve, it first determines which resolvers can read that file by checking their canRead property. If only one resolver matches a file, then only that one resolver is called, regardless of its order. If multiple resolvers match a file, then those resolvers are tried in order until one of them successfully reads the file. Once a resolver successfully reads the file, the rest of the resolvers are skipped.
      */
-    order?: number
+    order?: number;
 
     /**
      * The `canRead` property tells JSON Schema `$Ref` Parser what kind of files your resolver can read. In this example, we've simply specified a regular expression that matches "mogodb://" URLs, but we could have used a simple boolean, or even a function with custom logic to determine which files to resolve. Here are examples of each approach:
      */
-    canRead: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean)
+    canRead: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
 
     /**
      * This is where the real work of a resolver happens. The `read` method accepts the same file info object as the `canRead` function, but rather than returning a boolean value, the `read` method should return the contents of the file. The file contents should be returned in as raw a form as possible, such as a string or a byte array. Any further parsing or processing should be done by parsers.
@@ -283,7 +284,7 @@ declare namespace $RefParser {
     read(
       file: FileInfo,
       callback?: (error: Error | null, data: string | null) => any
-    ): string | Buffer | Promise<string | Buffer>
+    ): string | Buffer | Promise<string | Buffer>;
   }
 
   export interface ParserOptions {
@@ -293,21 +294,21 @@ declare namespace $RefParser {
      *
      * You can change the order in which parsers run, which is useful if you know that most of your referenced files will be a certain type, or if you add your own custom parser that you want to run first.
      */
-    order?: number
+    order?: number;
 
     /**
      * All of the built-in parsers allow empty files by default. The JSON and YAML parsers will parse empty files as `undefined`. The text parser will parse empty files as an empty string. The binary parser will parse empty files as an empty byte array.
      *
      * You can set `allowEmpty: false` on any parser, which will cause an error to be thrown if a file empty.
      */
-    allowEmpty?: boolean
+    allowEmpty?: boolean;
 
     /**
      * Determines which parsers will be used for which files.
      *
      * A regular expression can be used to match files by their full path. A string (or array of strings) can be used to match files by their file extension. Or a function can be used to perform more complex matching logic. See the custom parser docs for details.
      */
-    canParse?: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean)
+    canParse?: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
 
     /**
      * This is where the real work of a parser happens. The `parse` method accepts the same file info object as the `canParse` function, but rather than returning a boolean value, the `parse` method should return a JavaScript representation of the file contents.  For our CSV parser, that is a two-dimensional array of lines and values.  For your parser, it might be an object, a string, a custom class, or anything else.
@@ -317,7 +318,7 @@ declare namespace $RefParser {
     parse(
       file: FileInfo,
       callback?: (error: Error | null, data: string | null) => any
-    ): unknown | Promise<unknown>
+    ): unknown | Promise<unknown>;
   }
 
   /**
@@ -332,17 +333,17 @@ declare namespace $RefParser {
     /**
      * The full URL of the file. This could be any type of URL, including "http://", "https://", "file://", "ftp://", "mongodb://", or even a local filesystem path (when running in Node.js).
      */
-    url: string
+    url: string;
 
     /**
      * The lowercase file extension, such as ".json", ".yaml", ".txt", etc.
      */
-    extension: string
+    extension: string;
 
     /**
      * The raw file contents, in whatever form they were returned by the resolver that read the file.
      */
-    data: string | Buffer
+    data: string | Buffer;
   }
 
   /**
@@ -358,7 +359,7 @@ declare namespace $RefParser {
      *
      * See https://apitools.dev/json-schema-ref-parser/docs/refs.html#circular
      */
-    circular: boolean
+    public circular: boolean;
 
     /**
      * Returns the paths/URLs of all the files in your schema (including the main schema file).
@@ -367,7 +368,7 @@ declare namespace $RefParser {
      *
      * @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
      */
-    paths(...types: string[]): string[]
+    public paths(...types: string[]): string[]
 
     /**
      * Returns a map of paths/URLs and their correspond values.
@@ -376,7 +377,7 @@ declare namespace $RefParser {
      *
      * @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
      */
-    values(...types: string[]): { [url: string]: $RefParser.JSONSchema }
+    public values(...types: string[]): { [url: string]: $RefParser.JSONSchema }
 
     /**
      * Returns `true` if the given path exists in the schema; otherwise, returns `false`
@@ -385,7 +386,7 @@ declare namespace $RefParser {
      *
      * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
      */
-    exists($ref: string): boolean
+    public exists($ref: string): boolean
 
     /**
      * Gets the value at the given path in the schema. Throws an error if the path does not exist.
@@ -394,7 +395,7 @@ declare namespace $RefParser {
      *
      * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
      */
-    get($ref: string): JSONSchema4Type | JSONSchema6Type
+    public get($ref: string): JSONSchema4Type | JSONSchema6Type
 
     /**
      * 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.
@@ -402,18 +403,18 @@ 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.)
      */
-    set($ref: string, value: JSONSchema4Type | JSONSchema6Type): void
+    public set($ref: string, value: JSONSchema4Type | JSONSchema6Type): void
   }
 
   export type JSONParserErrorType = "EUNKNOWN" | "EPARSER" | "EUNMATCHEDPARSER" | "ERESOLVER" | "EUNMATCHEDRESOLVER" | "EMISSINGPOINTER" | "EINVALIDPOINTER";
 
   export class JSONParserError extends Error {
-    readonly name: string;
-    readonly message: string;
-    readonly source: string;
-    readonly path: Array<string | number>;
-    readonly errors: string;
-    readonly code: JSONParserErrorType;
+    public readonly name: string;
+    public readonly message: string;
+    public readonly source: string;
+    public readonly path: Array<string | number>;
+    public readonly errors: string;
+    public readonly code: JSONParserErrorType;
   }
 
   export class JSONParserErrorGroup extends Error {
@@ -422,44 +423,44 @@ declare namespace $RefParser {
      *
      * See https://github.com/APIDevTools/json-schema-ref-parser/blob/master/docs/ref-parser.md#errors
      */
-    readonly errors: Array<$RefParser.JSONParserError | $RefParser.InvalidPointerError | $RefParser.ResolverError | $RefParser.ParserError | $RefParser.MissingPointerError | $RefParser.UnmatchedParserError | $RefParser.UnmatchedResolverError>;
+    public readonly errors: Array<$RefParser.JSONParserError | $RefParser.InvalidPointerError | $RefParser.ResolverError | $RefParser.ParserError | $RefParser.MissingPointerError | $RefParser.UnmatchedParserError | $RefParser.UnmatchedResolverError>;
 
     /**
      * The fields property is a `$RefParser` instance
      *
      * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html
      */
-    readonly files: $RefParser;
+    public readonly files: $RefParser;
 
     /**
      * User friendly message containing the total amount of errors, as well as the absolute path to the source document
      */
-    readonly message: string;
+    public readonly message: string;
   }
 
   export class ParserError extends JSONParserError {
-    readonly name = "ParserError";
-    readonly code = "EPARSER";
+    public readonly name = "ParserError";
+    public readonly code = "EPARSER";
   }
   export class UnmatchedParserError extends JSONParserError {
-    readonly name = "UnmatchedParserError";
-    readonly code ="EUNMATCHEDPARSER";
+    public readonly name = "UnmatchedParserError";
+    public readonly code ="EUNMATCHEDPARSER";
   }
   export class ResolverError extends JSONParserError {
-    readonly name = "ResolverError";
-    readonly code ="ERESOLVER";
-    readonly ioErrorCode?: string;
+    public readonly name = "ResolverError";
+    public readonly code ="ERESOLVER";
+    public readonly ioErrorCode?: string;
   }
   export class UnmatchedResolverError extends JSONParserError {
-    readonly name = "UnmatchedResolverError";
-    readonly code ="EUNMATCHEDRESOLVER";
+    public readonly name = "UnmatchedResolverError";
+    public readonly code ="EUNMATCHEDRESOLVER";
   }
   export class MissingPointerError extends JSONParserError {
-    readonly name = "MissingPointerError";
-    readonly code ="EMISSINGPOINTER";
+    public readonly name = "MissingPointerError";
+    public readonly code ="EMISSINGPOINTER";
   }
   export class InvalidPointerError extends JSONParserError {
-    readonly name = "InvalidPointerError";
-    readonly code ="EINVALIDPOINTER";
+    public readonly name = "InvalidPointerError";
+    public readonly code ="EINVALIDPOINTER";
   }
 }

package/lib/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-unused-vars */
 "use strict";
 
 const $Refs = require("./refs");

package/lib/parsers/json.js

@@ -36,7 +36,7 @@ module.exports = {
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
    * @returns {Promise}
    */
-  async parse (file) {
+  async parse (file) {      // eslint-disable-line require-await
     let data = file.data;
     if (Buffer.isBuffer(data)) {
       data = data.toString();

package/lib/parsers/yaml.js

@@ -37,7 +37,7 @@ module.exports = {
    * @param {*}      file.data      - The file contents. This will be whatever data type was returned by the resolver
    * @returns {Promise}
    */
-  async parse (file) {
+  async parse (file) {      // eslint-disable-line require-await
     let data = file.data;
     if (Buffer.isBuffer(data)) {
       data = data.toString();

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,7 @@ 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);
       pointer.indirections += resolved.indirections + 1;
 
       if ($Ref.isExtended$Ref(pointer.value)) {

package/lib/ref.js

@@ -3,7 +3,7 @@
 module.exports = $Ref;
 
 const Pointer = require("./pointer");
-const { JSONParserError, JSONParserErrorGroup, ParserError, MissingPointerError, ResolverError, InvalidPointerError, isHandledError, normalizeError } = require("./util/errors");
+const { InvalidPointerError, isHandledError, normalizeError } = require("./util/errors");
 const { safePointerToPath, stripHash, getHash } = require("./util/url");
 
 /**
@@ -112,7 +112,7 @@ $Ref.prototype.get = function (path, options) {
 $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/refs.js

@@ -41,7 +41,7 @@ function $Refs () {
  * @param {...string|string[]} [types] - Only return paths of the given types ("file", "http", etc.)
  * @returns {string[]}
  */
-$Refs.prototype.paths = function (types) {
+$Refs.prototype.paths = function (types) {    // eslint-disable-line no-unused-vars
   let paths = getPaths(this._$refs, arguments);
   return paths.map((path) => {
     return path.decoded;
@@ -54,7 +54,7 @@ $Refs.prototype.paths = function (types) {
  * @param {...string|string[]} [types] - Only return references of the given types ("file", "http", etc.)
  * @returns {object}
  */
-$Refs.prototype.values = function (types) {
+$Refs.prototype.values = function (types) {   // eslint-disable-line no-unused-vars
   let $refs = this._$refs;
   let paths = getPaths($refs, arguments);
   return paths.reduce((obj, path) => {

package/lib/resolve-external.js

@@ -54,7 +54,7 @@ function resolveExternal (parser, options) {
 function crawl (obj, path, $refs, options) {
   let promises = [];
 
-  if (obj && typeof obj === "object") {
+  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     if ($Ref.isExternal$Ref(obj)) {
       promises.push(resolve$Ref(obj, path, $refs, options));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "9.0.2",
+  "version": "9.0.7",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",
@@ -42,7 +42,7 @@
     "test": "npm run test:node && npm run test:typescript && npm run test:browser && npm run lint",
     "test:node": "mocha",
     "test:browser": "karma start --single-run",
-    "test:typescript": "tsc --noEmit --strict --lib esnext test/specs/typescript-definition.spec.ts",
+    "test:typescript": "tsc --noEmit --strict --lib esnext,dom test/specs/typescript-definition.spec.ts",
     "coverage": "npm run coverage:node && npm run coverage:browser",
     "coverage:node": "nyc node_modules/mocha/bin/mocha",
     "coverage:browser": "npm run test:browser -- --coverage",
@@ -51,26 +51,26 @@
     "release": "npm run upgrade && npm run clean && npm test && npm run bump"
   },
   "devDependencies": {
-    "@babel/polyfill": "^7.10.4",
-    "@jsdevtools/eslint-config-modular": "^8.0.3",
-    "@jsdevtools/host-environment": "^2.0.3",
-    "@jsdevtools/karma-config": "^3.1.4",
-    "@jsdevtools/version-bump-prompt": "^6.0.3",
-    "@types/json-schema": "^7.0.4",
-    "@types/node": "^14.0.19",
+    "@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.1.0",
+    "@types/json-schema": "^7.0.6",
+    "@types/node": "^14.14.21",
     "chai": "^4.2.0",
     "chai-subset": "^1.6.0",
-    "eslint": "^7.4.0",
+    "eslint": "^7.18.0",
     "karma": "^5.0.2",
     "karma-cli": "^2.0.0",
-    "mocha": "^8.0.1",
+    "mocha": "^8.2.1",
     "npm-check": "^5.9.0",
     "nyc": "^15.0.1",
     "shx": "^0.3.2",
-    "typescript": "^3.9.6"
+    "typescript": "^4.0.5"
   },
   "dependencies": {
-    "@jsdevtools/ono": "^7.1.2",
+    "@jsdevtools/ono": "^7.1.3",
     "call-me-maybe": "^1.0.1",
     "js-yaml": "^3.13.1"
   }