@apidevtools/json-schema-ref-parser 9.1.0 → 10.0.0

package/README.md

@@ -1,19 +1,16 @@
-JSON Schema $Ref Parser
-============================
+# JSON Schema $Ref Parser
+
+_**This package needs [a new maintainer](https://github.com/APIDevTools/json-schema-ref-parser/issues/285) or at least some contributors. For more information [please read this article](https://phil.tech/2022/bundling-openapi-with-javascript/). As of v10.0.0 I am no longer spending any time working on this tool, so I can focus on scaling up my [reforestation charity](https://protect.earth/) instead of burning myself out trying to maintain a whole load of OSS projects I don't use in my vanishingly small spare time. Get in touch if you'd like to take over.** - [Phil Sturgeon](https://github.com/philsturgeon)_
+
 #### 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/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)
-[![Dependencies](https://david-dm.org/APIDevTools/json-schema-ref-parser.svg)](https://david-dm.org/APIDevTools/json-schema-ref-parser)
 [![License](https://img.shields.io/npm/l/@apidevtools/json-schema-ref-parser.svg)](LICENSE)
 [![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/actions)
-
-
 The Problem:
 --------------------------
 You've got a JSON Schema with `$ref` pointers to other files and/or URLs.  Maybe you know all the referenced files ahead of time.  Maybe you don't.  Maybe some are local files, and others are remote URLs.  Maybe they are a mix of JSON and YAML format.  Maybe some of the files contain cross-references to each other.
@@ -111,6 +108,13 @@ When using a transpiler such as [Babel](https://babeljs.io/) or [TypeScript](htt
 import $RefParser from "@apidevtools/json-schema-ref-parser";
 ```
 
+If you are using Node.js < 18, you'll need a polyfill for `fetch`, like [node-fetch](https://github.com/node-fetch/node-fetch):
+```javascript
+import fetch from "node-fetch";
+
+globalThis.fetch = fetch;
+```
+
 
 
 Browser support

package/cjs/bundle.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _refJs = /*#__PURE__*/ _interopRequireDefault(require("./ref.js"));
+var _pointerJs = /*#__PURE__*/ _interopRequireDefault(require("./pointer.js"));
+var _urlJs = /*#__PURE__*/ _interopRequireWildcard(require("./util/url.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _default = bundle;
+/**
+ * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
+ * only has *internal* references, not any *external* references.
+ * This method mutates the JSON schema object, adding new references and re-mapping existing ones.
+ *
+ * @param {$RefParser} parser
+ * @param {$RefParserOptions} options
+ */ function bundle(parser, options) {
+    // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
+    // Build an inventory of all $ref pointers in the JSON Schema
+    var inventory = [];
+    crawl(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
+    // Remap all $ref pointers
+    remap(inventory);
+}
+/**
+ * Recursively crawls the given value, and inventories all JSON references.
+ *
+ * @param {object} parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
+ * @param {string} key - The property key of `parent` to be crawled
+ * @param {string} path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
+ * @param {string} pathFromRoot - The path of the property being crawled, from the schema root
+ * @param {object[]} inventory - An array of already-inventoried $ref pointers
+ * @param {$Refs} $refs
+ * @param {$RefParserOptions} options
+ */ function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs, options) {
+    var obj = key === null ? parent : parent[key];
+    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+        if (_refJs.default.isAllowed$Ref(obj)) {
+            inventory$Ref(parent, key, path, pathFromRoot, indirections, inventory, $refs, options);
+        } else {
+            // Crawl the object in a specific order that's optimized for bundling.
+            // This is important because it determines how `pathFromRoot` gets built,
+            // which later determines which keys get dereferenced and which ones get remapped
+            var keys = Object.keys(obj).sort(function(a, b) {
+                // Most people will expect references to be bundled into the the "definitions" property,
+                // so we always crawl that property first, if it exists.
+                if (a === "definitions") {
+                    return -1;
+                } else if (b === "definitions") {
+                    return 1;
+                } else {
+                    // Otherwise, crawl the keys based on their length.
+                    // This produces the shortest possible bundled references
+                    return a.length - b.length;
+                }
+            });
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                // eslint-disable-next-line no-shadow
+                for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _$key = _step.value;
+                    var keyPath = _pointerJs.default.join(path, _$key);
+                    var keyPathFromRoot = _pointerJs.default.join(pathFromRoot, _$key);
+                    var value = obj[_$key];
+                    if (_refJs.default.isAllowed$Ref(value)) {
+                        inventory$Ref(obj, _$key, path, keyPathFromRoot, indirections, inventory, $refs, options);
+                    } else {
+                        crawl(obj, _$key, keyPath, keyPathFromRoot, indirections, inventory, $refs, options);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Inventories the given JSON Reference (i.e. records detailed information about it so we can
+ * optimize all $refs in the schema), and then crawls the resolved value.
+ *
+ * @param {object} $refParent - The object that contains a JSON Reference as one of its keys
+ * @param {string} $refKey - The key in `$refParent` that is a JSON Reference
+ * @param {string} path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
+ * @param {string} pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
+ * @param {object[]} inventory - An array of already-inventoried $ref pointers
+ * @param {$Refs} $refs
+ * @param {$RefParserOptions} options
+ */ function inventory$Ref($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
+    var $ref = $refKey === null ? $refParent : $refParent[$refKey];
+    var $refPath = _urlJs.resolve(path, $ref.$ref);
+    var pointer = $refs._resolve($refPath, pathFromRoot, options);
+    if (pointer === null) {
+        return;
+    }
+    var depth = _pointerJs.default.parse(pathFromRoot).length;
+    var file = _urlJs.stripHash(pointer.path);
+    var hash = _urlJs.getHash(pointer.path);
+    var external = file !== $refs._root$Ref.path;
+    var extended = _refJs.default.isExtended$Ref($ref);
+    indirections += pointer.indirections;
+    var existingEntry = findInInventory(inventory, $refParent, $refKey);
+    if (existingEntry) {
+        // This $Ref has already been inventoried, so we don't need to process it again
+        if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
+            removeFromInventory(inventory, existingEntry);
+        } else {
+            return;
+        }
+    }
+    inventory.push({
+        $ref: $ref,
+        parent: $refParent,
+        key: $refKey,
+        pathFromRoot: pathFromRoot,
+        depth: depth,
+        file: file,
+        hash: hash,
+        value: pointer.value,
+        circular: pointer.circular,
+        extended: extended,
+        external: external,
+        indirections: indirections
+    });
+    // Recursively crawl the resolved value
+    if (!existingEntry || external) {
+        crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
+    }
+}
+/**
+ * Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
+ * Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
+ * value are re-mapped to point to the first reference.
+ *
+ * @example:
+ *  {
+ *    first: { $ref: somefile.json#/some/part },
+ *    second: { $ref: somefile.json#/another/part },
+ *    third: { $ref: somefile.json },
+ *    fourth: { $ref: somefile.json#/some/part/sub/part }
+ *  }
+ *
+ * In this example, there are four references to the same file, but since the third reference points
+ * to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
+ * remapped to point inside the third one.
+ *
+ * On the other hand, if the third reference DIDN'T exist, then the first and second would both need
+ * to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
+ * need to be dereferenced, because it can be remapped to point inside the first one.
+ *
+ * @param {object[]} inventory
+ */ function remap(inventory) {
+    // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
+    inventory.sort(function(a, b) {
+        if (a.file !== b.file) {
+            // Group all the $refs that point to the same file
+            return a.file < b.file ? -1 : +1;
+        } else if (a.hash !== b.hash) {
+            // Group all the $refs that point to the same part of the file
+            return a.hash < b.hash ? -1 : +1;
+        } else if (a.circular !== b.circular) {
+            // If the $ref points to itself, then sort it higher than other $refs that point to this $ref
+            return a.circular ? -1 : +1;
+        } else if (a.extended !== b.extended) {
+            // If the $ref extends the resolved value, then sort it lower than other $refs that don't extend the value
+            return a.extended ? +1 : -1;
+        } else if (a.indirections !== b.indirections) {
+            // Sort direct references higher than indirect references
+            return a.indirections - b.indirections;
+        } else if (a.depth !== b.depth) {
+            // Sort $refs by how close they are to the JSON Schema root
+            return a.depth - b.depth;
+        } else {
+            // Determine how far each $ref is from the "definitions" property.
+            // Most people will expect references to be bundled into the the "definitions" property if possible.
+            var aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
+            var bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+            if (aDefinitionsIndex !== bDefinitionsIndex) {
+                // Give higher priority to the $ref that's closer to the "definitions" property
+                return bDefinitionsIndex - aDefinitionsIndex;
+            } else {
+                // All else is equal, so use the shorter path, which will produce the shortest possible reference
+                return a.pathFromRoot.length - b.pathFromRoot.length;
+            }
+        }
+    });
+    var file, hash, pathFromRoot;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = inventory[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var entry = _step.value;
+            // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
+            if (!entry.external) {
+                // This $ref already resolves to the main JSON Schema file
+                entry.$ref.$ref = entry.hash;
+            } else if (entry.file === file && entry.hash === hash) {
+                // This $ref points to the same value as the prevous $ref, so remap it to the same path
+                entry.$ref.$ref = pathFromRoot;
+            } else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
+                // This $ref points to a sub-value of the prevous $ref, so remap it beneath that path
+                entry.$ref.$ref = _pointerJs.default.join(pathFromRoot, _pointerJs.default.parse(entry.hash.replace(hash, "#")));
+            } else {
+                // We've moved to a new file or new hash
+                file = entry.file;
+                hash = entry.hash;
+                pathFromRoot = entry.pathFromRoot;
+                // This is the first $ref to point to this value, so dereference the value.
+                // Any other $refs that point to the same value will point to this $ref instead
+                entry.$ref = entry.parent[entry.key] = _refJs.default.dereference(entry.$ref, entry.value);
+                if (entry.circular) {
+                    // This $ref points to itself
+                    entry.$ref.$ref = entry.pathFromRoot;
+                }
+            }
+        // console.log('    new value: %s', (entry.$ref && entry.$ref.$ref) ? entry.$ref.$ref : '[object Object]');
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * TODO
+ */ function findInInventory(inventory, $refParent, $refKey) {
+    for(var i = 0; i < inventory.length; i++){
+        var existingEntry = inventory[i];
+        if (existingEntry.parent === $refParent && existingEntry.key === $refKey) {
+            return existingEntry;
+        }
+    }
+}
+function removeFromInventory(inventory, entry) {
+    var index = inventory.indexOf(entry);
+    inventory.splice(index, 1);
+}

package/cjs/dereference.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _refJs = /*#__PURE__*/ _interopRequireDefault(require("./ref.js"));
+var _pointerJs = /*#__PURE__*/ _interopRequireDefault(require("./pointer.js"));
+var _ono = require("@jsdevtools/ono");
+var _urlJs = /*#__PURE__*/ _interopRequireWildcard(require("./util/url.js"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _default = dereference;
+/**
+ * Crawls the JSON schema, finds all JSON references, and dereferences them.
+ * This method mutates the JSON schema object, replacing JSON references with their resolved value.
+ *
+ * @param {$RefParser} parser
+ * @param {$RefParserOptions} options
+ */ function dereference(parser, options) {
+    // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
+    var dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", new Set(), new Set(), new Map(), parser.$refs, options);
+    parser.$refs.circular = dereferenced.circular;
+    parser.schema = dereferenced.value;
+}
+/**
+ * Recursively crawls the given value, and dereferences any JSON references.
+ *
+ * @param {*} obj - The value to crawl. If it's not an object or array, it will be ignored.
+ * @param {string} path - The full path of `obj`, possibly with a JSON Pointer in the hash
+ * @param {string} pathFromRoot - The path of `obj` from the schema root
+ * @param {Set<object>} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} processedObjects - An array of all the objects that have already been processed
+ * @param {Map<string,object>} dereferencedCache - An map of all the dereferenced objects
+ * @param {$Refs} $refs
+ * @param {$RefParserOptions} options
+ * @returns {{value: object, circular: boolean}}
+ */ function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options) {
+    var dereferenced;
+    var result = {
+        value: obj,
+        circular: false
+    };
+    var isExcludedPath = options.dereference.excludedPathMatcher;
+    if (options.dereference.circular === "ignore" || !processedObjects.has(obj)) {
+        if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
+            parents.add(obj);
+            processedObjects.add(obj);
+            if (_refJs.default.isAllowed$Ref(obj, options)) {
+                dereferenced = dereference$Ref(obj, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
+                result.circular = dereferenced.circular;
+                result.value = dereferenced.value;
+            } else {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.keys(obj)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var key = _step.value;
+                        var keyPath = _pointerJs.default.join(path, key);
+                        var keyPathFromRoot = _pointerJs.default.join(pathFromRoot, key);
+                        if (isExcludedPath(keyPathFromRoot)) {
+                            continue;
+                        }
+                        var value = obj[key];
+                        var circular = false;
+                        if (_refJs.default.isAllowed$Ref(value, options)) {
+                            dereferenced = dereference$Ref(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;
+                                if (options.dereference.onDereference) {
+                                    options.dereference.onDereference(value.$ref, obj[key]);
+                                }
+                            }
+                        } else {
+                            if (!parents.has(value)) {
+                                dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
+                                circular = dereferenced.circular;
+                                // Avoid pointless mutations; breaks frozen objects to no profit
+                                if (obj[key] !== dereferenced.value) {
+                                    obj[key] = dereferenced.value;
+                                }
+                            } else {
+                                circular = foundCircularReference(keyPath, $refs, options);
+                            }
+                        }
+                        // Set the "isCircular" flag if this or any other property is circular
+                        result.circular = result.circular || circular;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            parents.delete(obj);
+        }
+    }
+    return result;
+}
+/**
+ * Dereferences the given JSON Reference, and then crawls the resulting value.
+ *
+ * @param {{$ref: string}} $ref - The JSON Reference to resolve
+ * @param {string} path - The full path of `$ref`, possibly with a JSON Pointer in the hash
+ * @param {string} pathFromRoot - The path of `$ref` from the schema root
+ * @param {Set<object>} parents - An array of the parent objects that have already been dereferenced
+ * @param {Set<object>} processedObjects - An array of all the objects that have already been dereferenced
+ * @param {Map<string,object>} dereferencedCache - An map of all the dereferenced objects
+ * @param {$Refs} $refs
+ * @param {$RefParserOptions} options
+ * @returns {{value: object, circular: boolean}}
+ */ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options) {
+    // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
+    var $refPath = _urlJs.resolve(path, $ref.$ref);
+    var cache = dereferencedCache.get($refPath);
+    if (cache) {
+        var refKeys = Object.keys($ref);
+        if (refKeys.length > 1) {
+            var extraKeys = {};
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = refKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var key = _step.value;
+                    if (key !== "$ref" && !(key in cache.value)) {
+                        extraKeys[key] = $ref[key];
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            return {
+                circular: cache.circular,
+                value: Object.assign({}, cache.value, extraKeys)
+            };
+        }
+        return cache;
+    }
+    var pointer = $refs._resolve($refPath, path, options);
+    if (pointer === null) {
+        return {
+            circular: false,
+            value: null
+        };
+    }
+    // Check for circular references
+    var directCircular = pointer.circular;
+    var circular = directCircular || parents.has(pointer.value);
+    circular && foundCircularReference(path, $refs, options);
+    // Dereference the JSON reference
+    var dereferencedValue = _refJs.default.dereference($ref, pointer.value);
+    // Crawl the dereferenced value (unless it's circular)
+    if (!circular) {
+        // Determine if the dereferenced value is circular
+        var dereferenced = crawl(dereferencedValue, pointer.path, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options);
+        circular = dereferenced.circular;
+        dereferencedValue = dereferenced.value;
+    }
+    if (circular && !directCircular && options.dereference.circular === "ignore") {
+        // The user has chosen to "ignore" circular references, so don't change the value
+        dereferencedValue = $ref;
+    }
+    if (directCircular) {
+        // The pointer is a DIRECT circular reference (i.e. it references itself).
+        // So replace the $ref path with the absolute path from the JSON Schema root
+        dereferencedValue.$ref = pathFromRoot;
+    }
+    var dereferencedObject = {
+        circular: circular,
+        value: dereferencedValue
+    };
+    // only cache if no extra properties than $ref
+    if (Object.keys($ref).length === 1) {
+        dereferencedCache.set($refPath, dereferencedObject);
+    }
+    return dereferencedObject;
+}
+/**
+ * Called when a circular reference is found.
+ * It sets the {@link $Refs#circular} flag, and throws an error if options.dereference.circular is false.
+ *
+ * @param {string} keyPath - The JSON Reference path of the circular reference
+ * @param {$Refs} $refs
+ * @param {$RefParserOptions} options
+ * @returns {boolean} - always returns true, to indicate that a circular reference was found
+ */ function foundCircularReference(keyPath, $refs, options) {
+    $refs.circular = true;
+    if (!options.dereference.circular) {
+        throw _ono.ono.reference("Circular $ref pointer found at ".concat(keyPath));
+    }
+    return true;
+}