@apidevtools/json-schema-ref-parser 11.3.0 → 11.4.1

package/README.md

@@ -75,8 +75,13 @@ Example
 import $RefParser from "@apidevtools/json-schema-ref-parser";
 
 try {
-  let schema = await $RefParser.dereference(mySchema);
-  console.log(schema.definitions.person.properties.firstName);
+  await $RefParser.dereference(mySchema);
+  // note - by default, mySchema is modified in place, and the returned value is a reference to the same object
+  console.log(mySchema.definitions.person.properties.firstName);
+
+  // if you want to avoid modifying the original schema, you can disable the `mutateInputSchema` option
+  let clonedSchema = await $RefParser.dereference(mySchema, { mutateInputSchema: false });
+  console.log(clonedSchema.definitions.person.properties.firstName);
 } catch (err) {
   console.error(err);
 }

package/dist/lib/index.d.ts

@@ -1,8 +1,7 @@
 import $Refs from "./refs.js";
-import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError } from "./util/errors.js";
+import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } from "./util/errors.js";
 import type { ParserOptions } from "./options.js";
-import type { Plugin, $RefsCallback, JSONSchema, SchemaCallback, HTTPResolverOptions, FileInfo, ResolverOptions, JSONSchemaObject } from "./types/index.js";
-export { JSONSchemaObject, ResolverOptions, ParserError, UnmatchedResolverError, ResolverError, HTTPResolverOptions, FileInfo, UnmatchedParserError, ParserOptions, MissingPointerError, InvalidPointerError, JSONParserError, Plugin, JSONSchema, $RefsCallback, SchemaCallback, };
+import type { $RefsCallback, JSONSchema, SchemaCallback } from "./types/index.js";
 export type RefParserSchema = string | JSONSchema;
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
@@ -198,3 +197,4 @@ export declare const parse: typeof $RefParser.parse;
 export declare const resolve: typeof $RefParser.resolve;
 export declare const bundle: typeof $RefParser.bundle;
 export declare const dereference: typeof $RefParser.dereference;
+export { UnmatchedResolverError, JSONParserError, JSONSchema, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, ParserOptions, $RefsCallback, isHandledError, JSONParserErrorGroup, SchemaCallback, };

package/dist/lib/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dereference = exports.bundle = exports.resolve = exports.parse = exports.$RefParser = exports.JSONParserError = exports.InvalidPointerError = exports.MissingPointerError = exports.UnmatchedParserError = exports.ResolverError = exports.UnmatchedResolverError = exports.ParserError = void 0;
+exports.JSONParserErrorGroup = exports.isHandledError = exports.UnmatchedParserError = exports.ParserError = exports.ResolverError = exports.MissingPointerError = exports.InvalidPointerError = exports.JSONParserError = exports.UnmatchedResolverError = exports.dereference = exports.bundle = exports.resolve = exports.parse = exports.$RefParser = void 0;
 const refs_js_1 = __importDefault(require("./refs.js"));
 const parse_js_1 = __importDefault(require("./parse.js"));
 const normalize_args_js_1 = __importDefault(require("./normalize-args.js"));
@@ -42,6 +42,8 @@ Object.defineProperty(exports, "ResolverError", { enumerable: true, get: functio
 Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return errors_js_1.ParserError; } });
 Object.defineProperty(exports, "UnmatchedParserError", { enumerable: true, get: function () { return errors_js_1.UnmatchedParserError; } });
 Object.defineProperty(exports, "UnmatchedResolverError", { enumerable: true, get: function () { return errors_js_1.UnmatchedResolverError; } });
+Object.defineProperty(exports, "isHandledError", { enumerable: true, get: function () { return errors_js_1.isHandledError; } });
+Object.defineProperty(exports, "JSONParserErrorGroup", { enumerable: true, get: function () { return errors_js_1.JSONParserErrorGroup; } });
 const ono_1 = require("@jsdevtools/ono");
 const maybe_js_1 = __importDefault(require("./util/maybe.js"));
 /**

package/dist/lib/normalize-args.d.ts

@@ -1,10 +1,13 @@
+import type { JSONSchema, SchemaCallback } from "./types";
+import type $RefParserOptions from "./options";
 export default normalizeArgs;
+export interface NormalizedArguments {
+    path: string;
+    schema: JSONSchema;
+    options: $RefParserOptions;
+    callback: SchemaCallback;
+}
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
-declare function normalizeArgs(_args: Partial<IArguments>): {
-    path: string;
-    schema: any;
-    options: any;
-    callback: any;
-};
+declare function normalizeArgs(_args: Partial<IArguments>): NormalizedArguments;

package/dist/lib/normalize-args.js

@@ -36,7 +36,11 @@ function normalizeArgs(_args) {
         options = (0, options_js_1.getNewOptions)(options);
     }
     catch (e) {
-        console.log(e);
+        console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
+    }
+    if (!options.mutateInputSchema && typeof schema === "object") {
+        // Make a deep clone of the schema, so that we don't alter the original object
+        schema = JSON.parse(JSON.stringify(schema));
     }
     return {
         path,

package/dist/lib/options.d.ts

@@ -1,5 +1,5 @@
 import type { HTTPResolverOptions, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.js";
-type DeepPartial<T> = T extends object ? {
+export type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
 /**
@@ -8,7 +8,7 @@ type DeepPartial<T> = T extends object ? {
  * @param [options] - Overridden options
  * @class
  */
-interface $RefParserOptions {
+export interface $RefParserOptions {
     /**
      * The `parse` options determine how different types of files will be parsed.
      *
@@ -77,9 +77,16 @@ interface $RefParserOptions {
          * Default: `relative`
          */
         externalReferenceResolution?: "relative" | "root";
+        /**
+         * Whether to clone the schema before dereferencing it.
+         * This is useful when you want to dereference the same schema multiple times, but you don't want to modify the original schema.
+         * Default: `true` due to mutating the input being the default behavior historically
+         */
+        mutateInputSchema?: boolean;
     };
 }
-export declare const getNewOptions: (options: DeepPartial<$RefParserOptions>) => $RefParserOptions;
+export declare const getJsonSchemaRefParserDefaultOptions: () => $RefParserOptions;
+export declare const getNewOptions: (options: DeepPartial<$RefParserOptions> | undefined) => $RefParserOptions;
 export type Options = $RefParserOptions;
 export type ParserOptions = DeepPartial<$RefParserOptions>;
 export default $RefParserOptions;

package/dist/lib/options.js

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNewOptions = void 0;
+exports.getNewOptions = exports.getJsonSchemaRefParserDefaultOptions = void 0;
 const json_js_1 = __importDefault(require("./parsers/json.js"));
 const yaml_js_1 = __importDefault(require("./parsers/yaml.js"));
 const text_js_1 = __importDefault(require("./parsers/text.js"));
 const binary_js_1 = __importDefault(require("./parsers/binary.js"));
 const file_js_1 = __importDefault(require("./resolvers/file.js"));
 const http_js_1 = __importDefault(require("./resolvers/http.js"));
-const getDefaults = () => {
+const getJsonSchemaRefParserDefaultOptions = () => {
     const defaults = {
         /**
          * Determines how different types of files will be parsed.
@@ -70,11 +70,13 @@ const getDefaults = () => {
             excludedPathMatcher: () => false,
             referenceResolution: "relative",
         },
+        mutateInputSchema: true,
     };
     return defaults;
 };
+exports.getJsonSchemaRefParserDefaultOptions = getJsonSchemaRefParserDefaultOptions;
 const getNewOptions = (options) => {
-    const newOptions = getDefaults();
+    const newOptions = (0, exports.getJsonSchemaRefParserDefaultOptions)();
     if (options) {
         merge(newOptions, options);
     }

package/dist/lib/parse.js

@@ -33,13 +33,20 @@ exports.default = parse;
  */
 async function parse(path, $refs, options) {
     // Remove the URL fragment, if any
-    path = url.stripHash(path);
+    const hashIndex = path.indexOf("#");
+    let hash = "";
+    if (hashIndex >= 0) {
+        hash = path.substring(hashIndex);
+        // Remove the URL fragment, if any
+        path = path.substring(0, hashIndex);
+    }
     // Add a new $Ref for this file, even though we don't have the value yet.
     // This ensures that we don't simultaneously read & parse the same file multiple times
     const $ref = $refs._add(path);
     // This "file object" will be passed to all resolvers and parsers.
     const file = {
         url: path,
+        hash,
         extension: url.getExtension(path),
     };
     // Read the file and then parse the data
@@ -111,7 +118,6 @@ async function readFile(file, options, $refs) {
  * The promise resolves with the parsed file contents and the parser that was used.
  */
 async function parseFile(file, options, $refs) {
-    // console.log('Parsing %s', file.url);
     // Find the parsers that can read this file type.
     // If none of the parsers are an exact match for this file, then we'll try ALL of them.
     // This handles situations where the file IS a supported type, just with an unknown extension.

package/dist/lib/pointer.d.ts

@@ -74,7 +74,7 @@ declare class Pointer {
      * @param [originalPath]
      * @returns
      */
-    static parse(path: string, originalPath?: string): any;
+    static parse(path: string, originalPath?: string): string[];
     /**
      * Creates a JSON pointer path, by joining one or more tokens to a base path.
      *

package/dist/lib/pointer.js

@@ -165,22 +165,22 @@ class Pointer {
      */
     static parse(path, originalPath) {
         // Get the JSON pointer from the path's hash
-        let pointer = url.getHash(path).substr(1);
+        const pointer = url.getHash(path).substring(1);
         // If there's no pointer, then there are no tokens,
         // so return an empty array
         if (!pointer) {
             return [];
         }
         // Split into an array
-        pointer = pointer.split("/");
+        const split = pointer.split("/");
         // Decode each part, according to RFC 6901
-        for (let i = 0; i < pointer.length; i++) {
-            pointer[i] = safeDecodeURIComponent(pointer[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
+        for (let i = 0; i < split.length; i++) {
+            split[i] = safeDecodeURIComponent(split[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
         }
-        if (pointer[0] !== "") {
-            throw new errors_js_1.InvalidPointerError(pointer, originalPath === undefined ? path : originalPath);
+        if (split[0] !== "") {
+            throw new errors_js_1.InvalidPointerError(split, originalPath === undefined ? path : originalPath);
         }
-        return pointer.slice(1);
+        return split.slice(1);
     }
     /**
      * Creates a JSON pointer path, by joining one or more tokens to a base path.

package/dist/lib/types/index.d.ts

@@ -3,7 +3,7 @@ import type { JSONSchema4, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JS
 import type $Refs from "../refs.js";
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
-export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object) => any;
+export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object | null) => any;
 export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 /**
  * See https://apitools.dev/json-schema-ref-parser/docs/options.html
@@ -99,6 +99,10 @@ export interface FileInfo {
      * 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;
+    /**
+     * The hash (URL fragment) of the file URL, including the # symbol. If the URL doesn't have a hash, then this will be an empty string.
+     */
+    hash: string;
     /**
      * The lowercase file extension, such as ".json", ".yaml", ".txt", etc.
      */

package/dist/lib/util/url.d.ts

@@ -40,21 +40,21 @@ export declare function stripQuery(path: any): any;
  * @param path
  * @returns
  */
-export declare function getHash(path: any): any;
+export declare function getHash(path: undefined | string): string;
 /**
  * Removes the hash (URL fragment), if any, from the given path.
  *
  * @param path
  * @returns
  */
-export declare function stripHash(path: any): any;
+export declare function stripHash(path?: string | undefined): string;
 /**
  * Determines whether the given path is an HTTP(S) URL.
  *
  * @param path
  * @returns
  */
-export declare function isHttp(path: any): boolean;
+export declare function isHttp(path: string): boolean;
 /**
  * Determines whether the given path is a filesystem path.
  * This includes "file://" URLs.

package/dist/lib/util/url.js

@@ -52,12 +52,13 @@ exports.parse = parse;
 function resolve(from, to) {
     const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "resolve://");
     const resolvedUrl = new URL((0, convert_path_to_posix_1.default)(to), fromUrl);
+    const endSpaces = to.match(/(\s*)$/)?.[1] || "";
     if (resolvedUrl.protocol === "resolve:") {
         // `from` is a relative URL.
         const { pathname, search, hash } = resolvedUrl;
-        return pathname + search + hash;
+        return pathname + search + hash + endSpaces;
     }
-    return resolvedUrl.toString();
+    return resolvedUrl.toString() + endSpaces;
 }
 exports.resolve = resolve;
 /**
@@ -129,9 +130,12 @@ exports.stripQuery = stripQuery;
  * @returns
  */
 function getHash(path) {
+    if (!path) {
+        return "#";
+    }
     const hashIndex = path.indexOf("#");
     if (hashIndex >= 0) {
-        return path.substr(hashIndex);
+        return path.substring(hashIndex);
     }
     return "#";
 }
@@ -143,9 +147,12 @@ exports.getHash = getHash;
  * @returns
  */
 function stripHash(path) {
+    if (!path) {
+        return "";
+    }
     const hashIndex = path.indexOf("#");
     if (hashIndex >= 0) {
-        path = path.substr(0, hashIndex);
+        path = path.substring(0, hashIndex);
     }
     return path;
 }

package/lib/index.ts

@@ -19,35 +19,7 @@ import {
 import { ono } from "@jsdevtools/ono";
 import maybe from "./util/maybe.js";
 import type { ParserOptions } from "./options.js";
-import type {
-  Plugin,
-  $RefsCallback,
-  JSONSchema,
-  SchemaCallback,
-  HTTPResolverOptions,
-  FileInfo,
-  ResolverOptions,
-  JSONSchemaObject,
-} from "./types/index.js";
-
-export {
-  JSONSchemaObject,
-  ResolverOptions,
-  ParserError,
-  UnmatchedResolverError,
-  ResolverError,
-  HTTPResolverOptions,
-  FileInfo,
-  UnmatchedParserError,
-  ParserOptions,
-  MissingPointerError,
-  InvalidPointerError,
-  JSONParserError,
-  Plugin,
-  JSONSchema,
-  $RefsCallback,
-  SchemaCallback,
-};
+import type { $RefsCallback, JSONSchema, SchemaCallback } from "./types/index.js";
 
 export type RefParserSchema = string | JSONSchema;
 
@@ -96,7 +68,6 @@ export class $RefParser {
     options: ParserOptions,
     callback: SchemaCallback,
   ): Promise<void>;
-
   async parse() {
     const args = normalizeArgs(arguments as any);
     let promise;
@@ -438,3 +409,19 @@ export const parse = $RefParser.parse;
 export const resolve = $RefParser.resolve;
 export const bundle = $RefParser.bundle;
 export const dereference = $RefParser.dereference;
+
+export {
+  UnmatchedResolverError,
+  JSONParserError,
+  JSONSchema,
+  InvalidPointerError,
+  MissingPointerError,
+  ResolverError,
+  ParserError,
+  UnmatchedParserError,
+  ParserOptions,
+  $RefsCallback,
+  isHandledError,
+  JSONParserErrorGroup,
+  SchemaCallback,
+};

package/lib/normalize-args.ts

@@ -1,11 +1,21 @@
 import { getNewOptions } from "./options.js";
+import type { JSONSchema, SchemaCallback } from "./types";
+import type $RefParserOptions from "./options";
 
 export default normalizeArgs;
 
+// I really dislike this function and the way it's written. It's not clear what it's doing, and it's way too flexible
+// In the future, I'd like to deprecate the api and accept only named parameters in index.ts
+export interface NormalizedArguments {
+  path: string;
+  schema: JSONSchema;
+  options: $RefParserOptions;
+  callback: SchemaCallback;
+}
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
-function normalizeArgs(_args: Partial<IArguments>) {
+function normalizeArgs(_args: Partial<IArguments>): NormalizedArguments {
   let path, schema, options, callback;
   const args = Array.prototype.slice.call(_args) as any[];
 
@@ -36,7 +46,12 @@ function normalizeArgs(_args: Partial<IArguments>) {
   try {
     options = getNewOptions(options);
   } catch (e) {
-    console.log(e);
+    console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
+  }
+
+  if (!options.mutateInputSchema && typeof schema === "object") {
+    // Make a deep clone of the schema, so that we don't alter the original object
+    schema = JSON.parse(JSON.stringify(schema));
   }
 
   return {

package/lib/options.ts

@@ -7,7 +7,7 @@ import httpResolver from "./resolvers/http.js";
 
 import type { HTTPResolverOptions, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.js";
 
-type DeepPartial<T> = T extends object
+export type DeepPartial<T> = T extends object
   ? {
       [P in keyof T]?: DeepPartial<T[P]>;
     }
@@ -18,7 +18,7 @@ type DeepPartial<T> = T extends object
  * @param [options] - Overridden options
  * @class
  */
-interface $RefParserOptions {
+export interface $RefParserOptions {
   /**
    * The `parse` options determine how different types of files will be parsed.
    *
@@ -91,10 +91,17 @@ interface $RefParserOptions {
      * Default: `relative`
      */
     externalReferenceResolution?: "relative" | "root";
+
+    /**
+     * Whether to clone the schema before dereferencing it.
+     * This is useful when you want to dereference the same schema multiple times, but you don't want to modify the original schema.
+     * Default: `true` due to mutating the input being the default behavior historically
+     */
+    mutateInputSchema?: boolean;
   };
 }
 
-const getDefaults = () => {
+export const getJsonSchemaRefParserDefaultOptions = () => {
   const defaults = {
     /**
      * Determines how different types of files will be parsed.
@@ -159,12 +166,14 @@ const getDefaults = () => {
       excludedPathMatcher: () => false,
       referenceResolution: "relative",
     },
+
+    mutateInputSchema: true,
   } as $RefParserOptions;
   return defaults;
 };
 
-export const getNewOptions = (options: DeepPartial<$RefParserOptions>): $RefParserOptions => {
-  const newOptions = getDefaults();
+export const getNewOptions = (options: DeepPartial<$RefParserOptions> | undefined): $RefParserOptions => {
+  const newOptions = getJsonSchemaRefParserDefaultOptions();
   if (options) {
     merge(newOptions, options);
   }

package/lib/parse.ts

@@ -19,7 +19,13 @@ export default parse;
  */
 async function parse(path: string, $refs: $Refs, options: Options) {
   // Remove the URL fragment, if any
-  path = url.stripHash(path);
+  const hashIndex = path.indexOf("#");
+  let hash = "";
+  if (hashIndex >= 0) {
+    hash = path.substring(hashIndex);
+    // Remove the URL fragment, if any
+    path = path.substring(0, hashIndex);
+  }
 
   // Add a new $Ref for this file, even though we don't have the value yet.
   // This ensures that we don't simultaneously read & parse the same file multiple times
@@ -28,6 +34,7 @@ async function parse(path: string, $refs: $Refs, options: Options) {
   // This "file object" will be passed to all resolvers and parsers.
   const file = {
     url: path,
+    hash,
     extension: url.getExtension(path),
   } as FileInfo;
 
@@ -103,8 +110,6 @@ async function readFile(file: FileInfo, options: Options, $refs: $Refs): Promise
  * The promise resolves with the parsed file contents and the parser that was used.
  */
 async function parseFile(file: FileInfo, options: Options, $refs: $Refs) {
-  // console.log('Parsing %s', file.url);
-
   // Find the parsers that can read this file type.
   // If none of the parsers are an exact match for this file, then we'll try ALL of them.
   // This handles situations where the file IS a supported type, just with an unknown extension.

package/lib/pointer.ts

@@ -190,9 +190,9 @@ class Pointer {
    * @param [originalPath]
    * @returns
    */
-  static parse(path: string, originalPath?: string) {
+  static parse(path: string, originalPath?: string): string[] {
     // Get the JSON pointer from the path's hash
-    let pointer = url.getHash(path).substr(1);
+    const pointer = url.getHash(path).substring(1);
 
     // If there's no pointer, then there are no tokens,
     // so return an empty array
@@ -201,18 +201,18 @@ class Pointer {
     }
 
     // Split into an array
-    pointer = pointer.split("/");
+    const split = pointer.split("/");
 
     // Decode each part, according to RFC 6901
-    for (let i = 0; i < pointer.length; i++) {
-      pointer[i] = safeDecodeURIComponent(pointer[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
+    for (let i = 0; i < split.length; i++) {
+      split[i] = safeDecodeURIComponent(split[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
     }
 
-    if (pointer[0] !== "") {
-      throw new InvalidPointerError(pointer, originalPath === undefined ? path : originalPath);
+    if (split[0] !== "") {
+      throw new InvalidPointerError(split, originalPath === undefined ? path : originalPath);
     }
 
-    return pointer.slice(1);
+    return split.slice(1);
   }
 
   /**

package/lib/types/index.ts

@@ -10,7 +10,7 @@ import type $Refs from "../refs.js";
 
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
-export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object) => any;
+export type SchemaCallback = (err: Error | null, schema?: JSONSchema | object | null) => any;
 export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
 
 /**
@@ -130,6 +130,11 @@ export interface FileInfo {
    */
   url: string;
 
+  /**
+   * The hash (URL fragment) of the file URL, including the # symbol. If the URL doesn't have a hash, then this will be an empty string.
+   */
+  hash: string;
+
   /**
    * The lowercase file extension, such as ".json", ".yaml", ".txt", etc.
    */

package/lib/util/url.ts

@@ -28,12 +28,13 @@ export const parse = (u: string | URL) => new URL(u);
 export function resolve(from: string, to: string) {
   const fromUrl = new URL(convertPathToPosix(from), "resolve://");
   const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
+  const endSpaces = to.match(/(\s*)$/)?.[1] || "";
   if (resolvedUrl.protocol === "resolve:") {
     // `from` is a relative URL.
     const { pathname, search, hash } = resolvedUrl;
-    return pathname + search + hash;
+    return pathname + search + hash + endSpaces;
   }
-  return resolvedUrl.toString();
+  return resolvedUrl.toString() + endSpaces;
 }
 
 /**
@@ -105,10 +106,13 @@ export function stripQuery(path: any) {
  * @param path
  * @returns
  */
-export function getHash(path: any) {
+export function getHash(path: undefined | string) {
+  if (!path) {
+    return "#";
+  }
   const hashIndex = path.indexOf("#");
   if (hashIndex >= 0) {
-    return path.substr(hashIndex);
+    return path.substring(hashIndex);
   }
   return "#";
 }
@@ -119,10 +123,13 @@ export function getHash(path: any) {
  * @param path
  * @returns
  */
-export function stripHash(path: any) {
+export function stripHash(path?: string | undefined) {
+  if (!path) {
+    return "";
+  }
   const hashIndex = path.indexOf("#");
   if (hashIndex >= 0) {
-    path = path.substr(0, hashIndex);
+    path = path.substring(0, hashIndex);
   }
   return path;
 }
@@ -133,7 +140,7 @@ export function stripHash(path: any) {
  * @param path
  * @returns
  */
-export function isHttp(path: any) {
+export function isHttp(path: string) {
   const protocol = getProtocol(path);
   if (protocol === "http" || protocol === "https") {
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "11.3.0",
+  "version": "11.4.1",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "keywords": [
     "json",