@apidevtools/json-schema-ref-parser 9.0.1 → 9.0.6

package/README.md

@@ -2,7 +2,7 @@ JSON Schema $Ref Parser
 ============================
 #### Parse, Resolve, and Dereference JSON Schema $ref pointers
 
-[![Build Status](https://github.com/APIDevTools/json-schema-ref-parser/workflows/CI-CD/badge.svg?branch=master)](https://github.com/APIDevTools/json-schema-ref-parser/blob/master/.github/workflows/CI-CD.yaml)
+[![Build Status](https://github.com/APIDevTools/json-schema-ref-parser/workflows/CI-CD/badge.svg?branch=master)](https://github.com/APIDevTools/json-schema-ref-parser/actions)
 [![Coverage Status](https://coveralls.io/repos/github/APIDevTools/json-schema-ref-parser/badge.svg?branch=master)](https://coveralls.io/github/APIDevTools/json-schema-ref-parser)
 
 [![npm](https://img.shields.io/npm/v/@apidevtools/json-schema-ref-parser.svg)](https://www.npmjs.com/package/@apidevtools/json-schema-ref-parser)
@@ -11,7 +11,7 @@ JSON Schema $Ref Parser
 [![Buy us a tree](https://img.shields.io/badge/Treeware-%F0%9F%8C%B3-lightgreen)](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser)
 
 
-[![OS and Browser Compatibility](https://apitools.dev/img/badges/ci-badges-with-ie.svg)](https://github.com/APIDevTools/json-schema-ref-parser/blob/master/.github/workflows/CI-CD.yaml)
+[![OS and Browser Compatibility](https://apitools.dev/img/badges/ci-badges-with-ie.svg)](https://github.com/APIDevTools/json-schema-ref-parser/actions)
 
 
 The Problem:
@@ -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);
     }
@@ -135,7 +135,9 @@ function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, i
   });
 
   // Recursively crawl the resolved value
-  crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
+  if (!existingEntry) {
+    crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
+  }
 }
 
 /**

package/lib/dereference.js

@@ -39,7 +39,7 @@ function crawl (obj, path, pathFromRoot, parents, $refs, options) {
     circular: false
   };
 
-  if (obj && typeof obj === "object") {
+  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     parents.push(obj);
 
     if ($Ref.isAllowed$Ref(obj, options)) {
@@ -57,13 +57,19 @@ function crawl (obj, path, pathFromRoot, parents, $refs, options) {
         if ($Ref.isAllowed$Ref(value, options)) {
           dereferenced = dereference$Ref(value, keyPath, keyPathFromRoot, parents, $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 {
           if (parents.indexOf(value) === -1) {
             dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, $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);
@@ -96,7 +102,7 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, $refs, options) {
   // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
 
   let $refPath = url.resolve(path, $ref.$ref);
-  let pointer = $refs._resolve($refPath, pathFromRoot, options);
+  let pointer = $refs._resolve($refPath, path, options);
 
   if (pointer === null) {
     return {

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/parse.js

@@ -124,7 +124,7 @@ function parseFile (file, options, $refs) {
       .then(onParsed, onError);
 
     function onParsed (parser) {
-      if ((options.continueOnError || !parser.plugin.allowEmpty) && isEmpty(parser.result)) {
+      if (!parser.plugin.allowEmpty && isEmpty(parser.result)) {
         reject(ono.syntax(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`));
       }
       else {

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,8 +3,8 @@
 module.exports = $Ref;
 
 const Pointer = require("./pointer");
-const { JSONParserError, JSONParserErrorGroup, ParserError, MissingPointerError, ResolverError, isHandledError } = require("./util/errors");
-const { safePointerToPath } = require("./util/url");
+const { InvalidPointerError, isHandledError, normalizeError } = require("./util/errors");
+const { safePointerToPath, stripHash, getHash } = require("./util/url");
 
 /**
  * This class represents a single JSON reference and its resolved value.
@@ -61,11 +61,13 @@ $Ref.prototype.addError = function (err) {
     this.errors = [];
   }
 
+  // the path has been almost certainly set at this point,
+  // but just in case something went wrong, let's inject path if necessary
   if (Array.isArray(err.errors)) {
-    this.errors.push(...err.errors);
+    this.errors.push(...err.errors.map(normalizeError));
   }
   else {
-    this.errors.push(err);
+    this.errors.push(normalizeError(err));
   }
 };
 
@@ -110,14 +112,23 @@ $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)) {
       throw err;
     }
 
-    err.path = safePointerToPath(pathFromRoot);
+    if (err.path === null) {
+      err.path = safePointerToPath(getHash(pathFromRoot));
+    }
+
+    if (err instanceof InvalidPointerError) {
+      // this is a special case - InvalidPointerError is thrown when dereferencing external file,
+      // but the issue is caused by the source file that referenced the file that undergoes dereferencing
+      err.source = stripHash(pathFromRoot);
+    }
+
     this.addError(err);
     return null;
   }

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/lib/util/errors.js

@@ -11,7 +11,7 @@ const JSONParserError = exports.JSONParserError = class JSONParserError extends
     this.code = "EUNKNOWN";
     this.message = message;
     this.source = source;
-    this.path = [];
+    this.path = null;
 
     Ono.extend(this);
   }
@@ -122,3 +122,11 @@ function setErrorName (err) {
 exports.isHandledError = function (err) {
   return err instanceof JSONParserError || err instanceof JSONParserErrorGroup;
 };
+
+exports.normalizeError = function (err) {
+  if (err.path === null) {
+    err.path = [];
+  }
+
+  return err;
+};

package/lib/util/plugins.js

@@ -84,7 +84,9 @@ exports.run = function (plugins, method, file, $refs) {
           // A synchronous result was returned
           onSuccess(result);
         }
-        // else { the callback will be called }
+        else if (index === plugins.length) {
+          throw new Error("No promise has been returned or callback has been called.");
+        }
       }
       catch (e) {
         onError(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "9.0.1",
+  "version": "9.0.6",
   "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.7.0",
-    "@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",
+    "@babel/polyfill": "^7.10.4",
+    "@jsdevtools/eslint-config": "^1.0.7",
+    "@jsdevtools/host-environment": "^2.0.4",
+    "@jsdevtools/karma-config": "^3.1.7",
+    "@jsdevtools/version-bump-prompt": "^6.0.6",
     "@types/json-schema": "^7.0.4",
-    "@types/node": "^13.13.0",
+    "@types/node": "^14.0.25",
     "chai": "^4.2.0",
     "chai-subset": "^1.6.0",
-    "eslint": "^6.8.0",
+    "eslint": "^7.5.0",
     "karma": "^5.0.2",
     "karma-cli": "^2.0.0",
-    "mocha": "^7.1.1",
+    "mocha": "^8.0.1",
     "npm-check": "^5.9.0",
     "nyc": "^15.0.1",
     "shx": "^0.3.2",
-    "typescript": "^3.7.4"
+    "typescript": "^3.9.7"
   },
   "dependencies": {
-    "@jsdevtools/ono": "^7.1.2",
+    "@jsdevtools/ono": "^7.1.3",
     "call-me-maybe": "^1.0.1",
     "js-yaml": "^3.13.1"
   }