@apidevtools/json-schema-ref-parser 15.3.2 → 15.3.3

package/dist/lib/bundle.js

@@ -45,7 +45,7 @@ function crawl(parent, key, path, scopeBase, dynamicIdScope, pathFromRoot, indir
     const isExcludedPath = bundleOptions.excludedPathMatcher || (() => false);
     if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
         const currentScopeBase = dynamicIdScope ? getSchemaBasePath(scopeBase, obj) : scopeBase;
-        if ($Ref.isAllowed$Ref(obj)) {
+        if ($Ref.isAllowed$Ref(obj, options, dynamicIdScope)) {
             inventory$Ref(parent, key, path, currentScopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options);
         }
         else {
@@ -71,7 +71,7 @@ function crawl(parent, key, path, scopeBase, dynamicIdScope, pathFromRoot, indir
                 const keyPath = Pointer.join(path, key);
                 const keyPathFromRoot = Pointer.join(pathFromRoot, key);
                 const value = obj[key];
-                if ($Ref.isAllowed$Ref(value)) {
+                if ($Ref.isAllowed$Ref(value, options, dynamicIdScope)) {
                     const valueScopeBase = dynamicIdScope ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
                     inventory$Ref(obj, key, keyPath, valueScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
                 }

package/dist/lib/dereference.js

@@ -53,7 +53,7 @@ function crawl(obj, path, scopeBase, dynamicIdScope, pathFromRoot, parents, proc
             parents.add(obj);
             processedObjects.add(obj);
             const currentScopeBase = dynamicIdScope ? getSchemaBasePath(scopeBase, obj) : scopeBase;
-            if ($Ref.isAllowed$Ref(obj, options)) {
+            if ($Ref.isAllowed$Ref(obj, options, dynamicIdScope)) {
                 dereferenced = dereference$Ref(obj, path, currentScopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
                 result.circular = dereferenced.circular;
                 result.value = dereferenced.value;
@@ -68,7 +68,7 @@ function crawl(obj, path, scopeBase, dynamicIdScope, pathFromRoot, parents, proc
                     }
                     const value = obj[key];
                     let circular;
-                    if ($Ref.isAllowed$Ref(value, options)) {
+                    if ($Ref.isAllowed$Ref(value, options, dynamicIdScope)) {
                         const valueScopeBase = dynamicIdScope ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
                         dereferenced = dereference$Ref(value, keyPath, valueScopeBase, dynamicIdScope, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
                         circular = dereferenced.circular;
@@ -153,18 +153,10 @@ function dereference$Ref($ref, path, scopeBase, dynamicIdScope, pathFromRoot, pa
         // If the cached object however is _not_ circular and there are additional keys alongside our
         // `$ref` pointer here we should merge them back in and return that.
         if (!cache.circular) {
-            const refKeys = Object.keys($ref);
-            if (refKeys.length > 1) {
-                const extraKeys = {};
-                for (const key of refKeys) {
-                    if (key !== "$ref" && !(key in cache.value)) {
-                        // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-                        extraKeys[key] = $ref[key];
-                    }
-                }
+            if (Object.keys($ref).length > 1) {
                 return {
                     circular: cache.circular,
-                    value: Object.assign({}, cache.value, extraKeys),
+                    value: $Ref.dereference($ref, cache.value, options, dynamicIdScope),
                 };
             }
             return cache;
@@ -210,7 +202,7 @@ function dereference$Ref($ref, path, scopeBase, dynamicIdScope, pathFromRoot, pa
         foundCircularReference(path, $refs, options);
     }
     // Dereference the JSON reference
-    let dereferencedValue = $Ref.dereference($ref, pointer.value, options);
+    let dereferencedValue = $Ref.dereference($ref, pointer.value, options, dynamicIdScope);
     // Crawl the dereferenced value (unless it's circular)
     if (!circular) {
         // Determine if the dereferenced value is circular

package/dist/lib/pointer.js

@@ -256,7 +256,7 @@ class Pointer {
  */
 function resolveIf$Ref(pointer, options, pathFromRoot) {
     // Is the value a JSON reference? (and allowed?)
-    if ($Ref.isAllowed$Ref(pointer.value, options)) {
+    if ($Ref.isAllowed$Ref(pointer.value, options, pointer.$ref.dynamicIdScope)) {
         const resolutionBase = pointer.$ref.dynamicIdScope ? pointer.scopeBase : pointer.path;
         const $refPath = url.resolve(resolutionBase, pointer.value.$ref);
         if ($refPath === pointer.path && !isRootPath(pathFromRoot)) {
@@ -272,7 +272,7 @@ function resolveIf$Ref(pointer, options, pathFromRoot) {
             if ($Ref.isExtended$Ref(pointer.value)) {
                 // This JSON reference "extends" the resolved value, rather than simply pointing to it.
                 // So the resolved path does NOT change.  Just the value does.
-                pointer.value = $Ref.dereference(pointer.value, resolved.value, options);
+                pointer.value = $Ref.dereference(pointer.value, resolved.value, options, pointer.$ref.dynamicIdScope);
                 if (pointer.$ref.dynamicIdScope) {
                     pointer.scopeBase = getSchemaBasePath(pointer.scopeBase, pointer.value);
                 }

package/dist/lib/ref.d.ts

@@ -114,7 +114,7 @@ declare class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = P
      * @param options
      * @returns
      */
-    static isAllowed$Ref<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>): true | undefined;
+    static isAllowed$Ref<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>, allowPlainNameFragments?: boolean): true | undefined;
     /**
      * Determines whether the given value is a JSON reference that "extends" its resolved value.
      * That is, it has extra properties (in addition to "$ref"), so rather than simply pointing to
@@ -182,6 +182,6 @@ declare class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = P
      * @param options - The options
      * @returns - Returns the dereferenced value
      */
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>($ref: $Ref<S, O>, resolvedValue: S, options?: O): S;
+    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>($ref: $Ref<S, O>, resolvedValue: S, options?: O, useSpecCompliantRefSiblings?: boolean): S;
 }
 export default $Ref;

package/dist/lib/ref.js

@@ -170,12 +170,16 @@ class $Ref {
      * @param options
      * @returns
      */
-    static isAllowed$Ref(value, options) {
+    static isAllowed$Ref(value, options, allowPlainNameFragments = false) {
         if (this.is$Ref(value)) {
             if (value.$ref.substring(0, 2) === "#/" || value.$ref === "#") {
                 // It's a JSON Pointer reference, which is always allowed
                 return true;
             }
+            else if (allowPlainNameFragments && value.$ref[0] === "#") {
+                // JSON Schema 2019-09+ allows plain-name fragments declared via $anchor/$dynamicAnchor
+                return true;
+            }
             else if (value.$ref[0] !== "#" && (!options || options.resolve?.external)) {
                 // It's an external reference, which is allowed by the options
                 return true;
@@ -252,7 +256,10 @@ class $Ref {
      * @param options - The options
      * @returns - Returns the dereferenced value
      */
-    static dereference($ref, resolvedValue, options) {
+    static dereference($ref, resolvedValue, options, useSpecCompliantRefSiblings = false) {
+        if ($Ref.isExtended$Ref($ref) && useSpecCompliantRefSiblings) {
+            return preserveRefSiblings($ref, resolvedValue);
+        }
         if (resolvedValue && typeof resolvedValue === "object" && $Ref.isExtended$Ref($ref)) {
             const merged = {};
             for (const key of Object.keys($ref)) {
@@ -287,6 +294,24 @@ class $Ref {
         }
     }
 }
+function preserveRefSiblings(refValue, resolvedValue) {
+    const preserved = {};
+    const existingAllOf = "allOf" in refValue ? refValue.allOf : undefined;
+    for (const key of Object.keys(refValue)) {
+        if (key !== "$ref" && key !== "allOf") {
+            preserved[key] = refValue[key];
+        }
+    }
+    const allOf = [resolvedValue];
+    if (Array.isArray(existingAllOf)) {
+        allOf.push(...existingAllOf);
+    }
+    else if (existingAllOf !== undefined) {
+        allOf.push(existingAllOf);
+    }
+    preserved.allOf = allOf;
+    return preserved;
+}
 function deepMerge(target, source) {
     //return {...target, ...source};
     // If either isn't an object, just return source (overwrite)

package/dist/lib/refs.d.ts

@@ -80,6 +80,7 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
      */
     _add(path: string): $Ref<S, O>;
     _addAlias(path: string, value: S, pathType?: string | unknown, dynamicIdScope?: boolean): $Ref<S, O>;
+    _addExactAlias(path: string, targetPath: string): string;
     /**
      * Resolves the given JSON reference.
      *
@@ -98,6 +99,7 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
      */
     _$refs: $RefsMap<S, O>;
     _aliases: $RefsMap<S, O>;
+    _exactAliases: Record<string, string>;
     /**
      * The {@link $Ref} object that is the root of the JSON schema.
      *

package/dist/lib/refs.js

@@ -99,7 +99,7 @@ export default class $Refs {
      */
     _get$Ref(path) {
         path = url.resolve(this._root$Ref.path, path);
-        return this._getRef(path);
+        return this._getRef(this._exactAliases[path] || path);
     }
     /**
      * Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
@@ -127,6 +127,13 @@ export default class $Refs {
         this._aliases[withoutHash] = $ref;
         return $ref;
     }
+    _addExactAlias(path, targetPath) {
+        if (!path || this._exactAliases[path]) {
+            return this._exactAliases[path];
+        }
+        this._exactAliases[path] = targetPath;
+        return targetPath;
+    }
     /**
      * Resolves the given JSON reference.
      *
@@ -138,11 +145,12 @@ export default class $Refs {
      */
     _resolve(path, pathFromRoot, options) {
         const absPath = url.resolve(this._root$Ref.path, path);
-        const $ref = this._getRef(absPath);
+        const canonicalPath = this._exactAliases[absPath] || absPath;
+        const $ref = this._getRef(canonicalPath);
         if (!$ref) {
             throw new Error(`Error resolving $ref pointer "${path}". \n"${url.stripHash(absPath)}" not found.`);
         }
-        return $ref.resolve(absPath, options, path, pathFromRoot);
+        return $ref.resolve(canonicalPath, options, path, pathFromRoot);
     }
     /**
      * A map of paths/urls to {@link $Ref} objects
@@ -152,6 +160,7 @@ export default class $Refs {
      */
     _$refs = {};
     _aliases = {};
+    _exactAliases = {};
     /**
      * The {@link $Ref} object that is the root of the JSON schema.
      *
@@ -168,6 +177,7 @@ export default class $Refs {
         this.circular = false;
         this._$refs = {};
         this._aliases = {};
+        this._exactAliases = {};
         // @ts-ignore
         this._root$Ref = null;
     }

package/dist/lib/util/schema-resources.js

@@ -20,20 +20,22 @@ export function registerSchemaResources($refs, basePath, value, pathType, dynami
         return;
     }
     const seen = new Set();
-    const visit = (node, scopeBase) => {
+    const visit = (node, scopeBase, pointerTokens) => {
         if (!node || typeof node !== "object" || ArrayBuffer.isView(node) || seen.has(node)) {
             return;
         }
         seen.add(node);
         const nextScopeBase = getSchemaBasePath(scopeBase, node);
+        const resourcePointerTokens = nextScopeBase === scopeBase ? pointerTokens : [];
         if (nextScopeBase !== scopeBase) {
             $refs._addAlias(nextScopeBase, node, pathType, dynamicIdScope);
         }
+        registerAnchorAliases($refs, nextScopeBase, resourcePointerTokens, node);
         for (const key of Object.keys(node)) {
-            visit(node[key], nextScopeBase);
+            visit(node[key], nextScopeBase, [...resourcePointerTokens, key]);
         }
     };
-    visit(value, basePath);
+    visit(value, basePath, []);
 }
 function getSchemaId(value) {
     if (value &&
@@ -45,3 +47,26 @@ function getSchemaId(value) {
     }
     return undefined;
 }
+function registerAnchorAliases($refs, scopeBase, pointerTokens, value) {
+    if (!value || typeof value !== "object" || ArrayBuffer.isView(value)) {
+        return;
+    }
+    const resourceBase = url.stripHash(scopeBase);
+    const targetPath = pointerTokens.length > 0 ? joinPointerPath(resourceBase, pointerTokens) : `${resourceBase}#`;
+    const anchors = [
+        value.$anchor,
+        value.$dynamicAnchor,
+    ];
+    for (const anchor of anchors) {
+        if (typeof anchor === "string" && anchor.length > 0) {
+            $refs._addExactAlias(`${resourceBase}#${anchor}`, targetPath);
+        }
+    }
+}
+function joinPointerPath(basePath, tokens) {
+    let path = `${basePath}#`;
+    for (const token of tokens) {
+        path += `/${token.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+    }
+    return path;
+}

package/lib/bundle.ts

@@ -97,7 +97,7 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
 
   if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
     const currentScopeBase = dynamicIdScope ? getSchemaBasePath(scopeBase, obj) : scopeBase;
-    if ($Ref.isAllowed$Ref(obj)) {
+    if ($Ref.isAllowed$Ref(obj, options, dynamicIdScope)) {
       inventory$Ref(parent, key, path, currentScopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options);
     } else {
       // Crawl the object in a specific order that's optimized for bundling.
@@ -122,7 +122,7 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
         const keyPathFromRoot = Pointer.join(pathFromRoot, key);
         const value = obj[key];
 
-        if ($Ref.isAllowed$Ref(value)) {
+        if ($Ref.isAllowed$Ref(value, options, dynamicIdScope)) {
           const valueScopeBase = dynamicIdScope ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
           inventory$Ref(
             obj,

package/lib/dereference.ts

@@ -94,7 +94,7 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
       processedObjects.add(obj);
       const currentScopeBase = dynamicIdScope ? getSchemaBasePath(scopeBase, obj) : scopeBase;
 
-      if ($Ref.isAllowed$Ref(obj, options)) {
+      if ($Ref.isAllowed$Ref(obj, options, dynamicIdScope)) {
         dereferenced = dereference$Ref(
           obj,
           path,
@@ -125,7 +125,7 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
           const value = obj[key];
           let circular;
 
-          if ($Ref.isAllowed$Ref(value, options)) {
+          if ($Ref.isAllowed$Ref(value, options, dynamicIdScope)) {
             const valueScopeBase = dynamicIdScope ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
             dereferenced = dereference$Ref(
               value,
@@ -257,18 +257,10 @@ function dereference$Ref<S extends object = JSONSchema, O extends ParserOptions<
     // If the cached object however is _not_ circular and there are additional keys alongside our
     // `$ref` pointer here we should merge them back in and return that.
     if (!cache.circular) {
-      const refKeys = Object.keys($ref);
-      if (refKeys.length > 1) {
-        const extraKeys = {};
-        for (const key of refKeys) {
-          if (key !== "$ref" && !(key in cache.value)) {
-            // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-            extraKeys[key] = $ref[key];
-          }
-        }
+      if (Object.keys($ref).length > 1) {
         return {
           circular: cache.circular,
-          value: Object.assign({}, cache.value, extraKeys),
+          value: $Ref.dereference($ref, cache.value, options, dynamicIdScope),
         };
       }
 
@@ -318,7 +310,7 @@ function dereference$Ref<S extends object = JSONSchema, O extends ParserOptions<
   }
 
   // Dereference the JSON reference
-  let dereferencedValue = $Ref.dereference($ref, pointer.value, options);
+  let dereferencedValue = $Ref.dereference($ref, pointer.value, options, dynamicIdScope);
 
   // Crawl the dereferenced value (unless it's circular)
   if (!circular) {

package/lib/pointer.ts

@@ -308,7 +308,7 @@ function resolveIf$Ref<S extends object = JSONSchema, O extends ParserOptions<S>
 ) {
   // Is the value a JSON reference? (and allowed?)
 
-  if ($Ref.isAllowed$Ref(pointer.value, options)) {
+  if ($Ref.isAllowed$Ref(pointer.value, options, pointer.$ref.dynamicIdScope)) {
     const resolutionBase = pointer.$ref.dynamicIdScope ? pointer.scopeBase : pointer.path;
     const $refPath = url.resolve(resolutionBase, pointer.value.$ref);
 
@@ -326,7 +326,7 @@ function resolveIf$Ref<S extends object = JSONSchema, O extends ParserOptions<S>
       if ($Ref.isExtended$Ref(pointer.value)) {
         // This JSON reference "extends" the resolved value, rather than simply pointing to it.
         // So the resolved path does NOT change.  Just the value does.
-        pointer.value = $Ref.dereference(pointer.value, resolved.value, options);
+        pointer.value = $Ref.dereference(pointer.value, resolved.value, options, pointer.$ref.dynamicIdScope);
         if (pointer.$ref.dynamicIdScope) {
           pointer.scopeBase = getSchemaBasePath(pointer.scopeBase, pointer.value);
         }

package/lib/ref.ts

@@ -199,11 +199,18 @@ class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOpt
    * @param options
    * @returns
    */
-  static isAllowed$Ref<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>) {
+  static isAllowed$Ref<S extends object = JSONSchema>(
+    value: unknown,
+    options?: ParserOptions<S>,
+    allowPlainNameFragments = false,
+  ) {
     if (this.is$Ref(value)) {
       if (value.$ref.substring(0, 2) === "#/" || value.$ref === "#") {
         // It's a JSON Pointer reference, which is always allowed
         return true;
+      } else if (allowPlainNameFragments && value.$ref[0] === "#") {
+        // JSON Schema 2019-09+ allows plain-name fragments declared via $anchor/$dynamicAnchor
+        return true;
       } else if (value.$ref[0] !== "#" && (!options || options.resolve?.external)) {
         // It's an external reference, which is allowed by the options
         return true;
@@ -286,7 +293,12 @@ class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOpt
     $ref: $Ref<S, O>,
     resolvedValue: S,
     options?: O,
+    useSpecCompliantRefSiblings = false,
   ): S {
+    if ($Ref.isExtended$Ref($ref) && useSpecCompliantRefSiblings) {
+      return preserveRefSiblings($ref, resolvedValue) as S;
+    }
+
     if (resolvedValue && typeof resolvedValue === "object" && $Ref.isExtended$Ref($ref)) {
       const merged = {} as Partial<S>;
       for (const key of Object.keys($ref)) {
@@ -325,6 +337,27 @@ class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOpt
   }
 }
 
+function preserveRefSiblings<T>(refValue: Record<string, any>, resolvedValue: T): T {
+  const preserved = {} as Record<string, any>;
+  const existingAllOf = "allOf" in refValue ? refValue.allOf : undefined;
+
+  for (const key of Object.keys(refValue)) {
+    if (key !== "$ref" && key !== "allOf") {
+      preserved[key] = refValue[key];
+    }
+  }
+
+  const allOf = [resolvedValue];
+  if (Array.isArray(existingAllOf)) {
+    allOf.push(...existingAllOf);
+  } else if (existingAllOf !== undefined) {
+    allOf.push(existingAllOf);
+  }
+
+  preserved.allOf = allOf;
+  return preserved as T;
+}
+
 function deepMerge<T>(target: Partial<T>, source: Partial<T>): T {
   //return {...target, ...source};
 

package/lib/refs.ts

@@ -112,7 +112,7 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
    */
   _get$Ref(path: string) {
     path = url.resolve(this._root$Ref.path!, path);
-    return this._getRef(path);
+    return this._getRef(this._exactAliases[path] || path);
   }
 
   /**
@@ -149,6 +149,15 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
     return $ref;
   }
 
+  _addExactAlias(path: string, targetPath: string) {
+    if (!path || this._exactAliases[path]) {
+      return this._exactAliases[path];
+    }
+
+    this._exactAliases[path] = targetPath;
+    return targetPath;
+  }
+
   /**
    * Resolves the given JSON reference.
    *
@@ -160,13 +169,14 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
    */
   _resolve(path: string, pathFromRoot: string, options?: O) {
     const absPath = url.resolve(this._root$Ref.path!, path);
-    const $ref = this._getRef(absPath);
+    const canonicalPath = this._exactAliases[absPath] || absPath;
+    const $ref = this._getRef(canonicalPath);
 
     if (!$ref) {
       throw new Error(`Error resolving $ref pointer "${path}". \n"${url.stripHash(absPath)}" not found.`);
     }
 
-    return $ref.resolve(absPath, options, path, pathFromRoot);
+    return $ref.resolve(canonicalPath, options, path, pathFromRoot);
   }
 
   /**
@@ -179,6 +189,8 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
 
   _aliases: $RefsMap<S, O> = {};
 
+  _exactAliases: Record<string, string> = {};
+
   /**
    * The {@link $Ref} object that is the root of the JSON schema.
    *
@@ -197,6 +209,7 @@ export default class $Refs<S extends object = JSONSchema, O extends ParserOption
 
     this._$refs = {};
     this._aliases = {};
+    this._exactAliases = {};
 
     // @ts-ignore
     this._root$Ref = null;

package/lib/util/schema-resources.ts

@@ -38,7 +38,7 @@ export function registerSchemaResources<S extends object = JSONSchema, O extends
 
   const seen = new Set<object>();
 
-  const visit = (node: unknown, scopeBase: string) => {
+  const visit = (node: unknown, scopeBase: string, pointerTokens: string[]) => {
     if (!node || typeof node !== "object" || ArrayBuffer.isView(node) || seen.has(node)) {
       return;
     }
@@ -46,16 +46,18 @@ export function registerSchemaResources<S extends object = JSONSchema, O extends
     seen.add(node);
 
     const nextScopeBase = getSchemaBasePath(scopeBase, node);
+    const resourcePointerTokens = nextScopeBase === scopeBase ? pointerTokens : [];
     if (nextScopeBase !== scopeBase) {
       $refs._addAlias(nextScopeBase, node as S, pathType, dynamicIdScope);
     }
+    registerAnchorAliases($refs, nextScopeBase, resourcePointerTokens, node);
 
     for (const key of Object.keys(node)) {
-      visit((node as Record<string, unknown>)[key], nextScopeBase);
+      visit((node as Record<string, unknown>)[key], nextScopeBase, [...resourcePointerTokens, key]);
     }
   };
 
-  visit(value, basePath);
+  visit(value, basePath, []);
 }
 
 function getSchemaId(value: unknown): string | undefined {
@@ -71,3 +73,37 @@ function getSchemaId(value: unknown): string | undefined {
 
   return undefined;
 }
+
+function registerAnchorAliases<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
+  $refs: $Refs<S, O>,
+  scopeBase: string,
+  pointerTokens: string[],
+  value: unknown,
+) {
+  if (!value || typeof value !== "object" || ArrayBuffer.isView(value)) {
+    return;
+  }
+
+  const resourceBase = url.stripHash(scopeBase);
+  const targetPath = pointerTokens.length > 0 ? joinPointerPath(resourceBase, pointerTokens) : `${resourceBase}#`;
+  const anchors = [
+    (value as { $anchor?: unknown }).$anchor,
+    (value as { $dynamicAnchor?: unknown }).$dynamicAnchor,
+  ];
+
+  for (const anchor of anchors) {
+    if (typeof anchor === "string" && anchor.length > 0) {
+      $refs._addExactAlias(`${resourceBase}#${anchor}`, targetPath);
+    }
+  }
+}
+
+function joinPointerPath(basePath: string, tokens: string[]) {
+  let path = `${basePath}#`;
+
+  for (const token of tokens) {
+    path += `/${token.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+  }
+
+  return path;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "15.3.2",
+  "version": "15.3.3",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "type": "module",
   "types": "dist/lib/index.d.ts",