@apidevtools/json-schema-ref-parser 11.7.3 → 11.9.0

package/README.md

@@ -155,14 +155,10 @@ To build/test the project locally on your computer:
 
 JSON Schema $Ref Parser is 100% free and open-source, under the [MIT license](LICENSE). Use it however you want.
 
-This package is [Treeware](http://treeware.earth). If you use it in production, then we ask that you [**buy the world a
-tree**](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser) to thank us for our work. By contributing to
-the Treeware forest you’ll be creating employment for local families and restoring wildlife habitats.
+## Thanks
 
-## Big Thanks To
+Thanks to these awesome contributors for their major support of this open-source project.
 
-Thanks to these awesome companies for their support of Open Source developers ❤
-
-[![Stoplight](https://svgshare.com/i/TK5.svg)](https://stoplight.io/?utm_source=github&utm_medium=readme&utm_campaign=json_schema_ref_parser)
-[![SauceLabs](https://jstools.dev/img/badges/sauce-labs.svg)](https://saucelabs.com)
-[![Coveralls](https://jstools.dev/img/badges/coveralls.svg)](https://coveralls.io)
+- [JonLuca De Caro](https://jonlu.ca)
+- [Phil Sturgeon](https://philsturgeon.com)
+- [Stoplight](https://stoplight.io/?utm_source=github&utm_medium=readme&utm_campaign=json_schema_ref_parser)

package/dist/lib/dereference.js

@@ -106,7 +106,28 @@ function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedC
                         circular = dereferenced.circular;
                         // Avoid pointless mutations; breaks frozen objects to no profit
                         if (obj[key] !== dereferenced.value) {
+                            // If we have properties we want to preserve from our dereferenced schema then we need
+                            // to copy them over to our new object.
+                            const preserved = new Map();
+                            if (derefOptions?.preservedProperties) {
+                                if (typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+                                    derefOptions?.preservedProperties.forEach((prop) => {
+                                        if (prop in obj[key]) {
+                                            preserved.set(prop, obj[key][prop]);
+                                        }
+                                    });
+                                }
+                            }
                             obj[key] = dereferenced.value;
+                            // If we have data to preserve and our dereferenced object is still an object then
+                            // we need copy back our preserved data into our dereferenced schema.
+                            if (derefOptions?.preservedProperties) {
+                                if (preserved.size && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+                                    preserved.forEach((value, prop) => {
+                                        obj[key][prop] = value;
+                                    });
+                                }
+                            }
                             derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
                         }
                     }
@@ -210,7 +231,8 @@ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, de
 }
 /**
  * Called when a circular reference is found.
- * It sets the {@link $Refs#circular} flag, and throws an error if options.dereference.circular is false.
+ * It sets the {@link $Refs#circular} flag, executes the options.dereference.onCircular callback,
+ * and throws an error if options.dereference.circular is false.
  *
  * @param keyPath - The JSON Reference path of the circular reference
  * @param $refs
@@ -219,6 +241,7 @@ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, de
  */
 function foundCircularReference(keyPath, $refs, options) {
     $refs.circular = true;
+    options?.dereference?.onCircular?.(keyPath);
     if (!options.dereference.circular) {
         throw ono_1.ono.reference(`Circular $ref pointer found at ${keyPath}`);
     }

package/dist/lib/index.d.ts

@@ -44,8 +44,8 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
     parse(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     parse(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
     parse(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+    static parse<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+    static parse<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
     static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
     static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
@@ -95,8 +95,8 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
      * @param options (optional)
      * @param callback (optional) A callback that will receive the bundled schema object
      */
-    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+    static bundle<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+    static bundle<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
     static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
     static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
@@ -129,8 +129,8 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
      * @param options (optional)
      * @param callback (optional) A callback that will receive the dereferenced schema object
      */
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+    static dereference<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+    static dereference<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
     static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
     static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;

package/dist/lib/options.d.ts

@@ -17,6 +17,12 @@ export interface DereferenceOptions {
      * subpaths contain literal $ref keys that should not be dereferenced.
      */
     excludedPathMatcher?(path: string): boolean;
+    /**
+     * Callback invoked during circular reference detection.
+     *
+     * @argument {string} path - The path that is circular (ie. the `$ref` string)
+     */
+    onCircular?(path: string): void;
     /**
      * Callback invoked during dereferencing.
      *
@@ -26,6 +32,15 @@ export interface DereferenceOptions {
      * @argument {string} parentPropName - The prop name of the parent object whose value was dereferenced
      */
     onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
+    /**
+     * An array of properties to preserve when dereferencing a `$ref` schema. Useful if you want to
+     * enforce non-standard dereferencing behavior like present in the OpenAPI 3.1 specification where
+     * `description` and `summary` properties are preserved when alongside a `$ref` pointer.
+     *
+     * If none supplied then no properties will be preserved and the object will be fully replaced
+     * with the dereferenced `$ref`.
+     */
+    preservedProperties?: string[];
     /**
      * Whether a reference should resolve relative to its directory/path, or from the cwd
      *
@@ -376,7 +391,9 @@ export declare const getNewOptions: <S extends object = JSONSchema, O extends Pa
     dereference?: {
         circular?: boolean | "ignore" | undefined;
         excludedPathMatcher?: {} | undefined;
+        onCircular?: {} | undefined;
         onDereference?: {} | undefined;
+        preservedProperties?: (string | undefined)[] | undefined;
         externalReferenceResolution?: "relative" | "root" | undefined;
     } | undefined;
     mutateInputSchema?: boolean | undefined;

package/dist/lib/pointer.js

@@ -83,6 +83,7 @@ class Pointer {
      */
     resolve(obj, options, pathFromRoot) {
         const tokens = Pointer.parse(this.path, this.originalPath);
+        const found = [];
         // Crawl the object, one token at a time
         this.value = unwrapOrThrow(obj);
         for (let i = 0; i < tokens.length; i++) {
@@ -110,11 +111,16 @@ class Pointer {
                     continue;
                 }
                 this.value = null;
-                throw new errors_js_1.MissingPointerError(token, decodeURI(this.originalPath));
+                const path = this.$ref.path || "";
+                const targetRef = this.path.replace(path, "");
+                const targetFound = Pointer.join("", found);
+                const parentPath = pathFromRoot?.replace(path, "");
+                throw new errors_js_1.MissingPointerError(token, decodeURI(this.originalPath), targetRef, targetFound, parentPath);
             }
             else {
                 this.value = this.value[token];
             }
+            found.push(token);
         }
         // Resolve the final value
         if (!this.value || (this.value.$ref && url.resolve(this.path, this.value.$ref) !== pathFromRoot)) {

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

@@ -41,7 +41,11 @@ export declare class UnmatchedResolverError extends JSONParserError {
 export declare class MissingPointerError extends JSONParserError {
     code: JSONParserErrorType;
     name: string;
-    constructor(token: string, path: string);
+    targetToken: any;
+    targetRef: string;
+    targetFound: string;
+    parentPath: string;
+    constructor(token: any, path: any, targetRef: any, targetFound: any, parentPath: any);
 }
 export declare class TimeoutError extends JSONParserError {
     code: JSONParserErrorType;

package/dist/lib/util/errors.js

@@ -78,10 +78,14 @@ class UnmatchedResolverError extends JSONParserError {
 }
 exports.UnmatchedResolverError = UnmatchedResolverError;
 class MissingPointerError extends JSONParserError {
-    constructor(token, path) {
+    constructor(token, path, targetRef, targetFound, parentPath) {
         super(`Missing $ref pointer "${(0, url_js_1.getHash)(path)}". Token "${token}" does not exist.`, (0, url_js_1.stripHash)(path));
         this.code = "EMISSINGPOINTER";
         this.name = "MissingPointerError";
+        this.targetToken = token;
+        this.targetRef = targetRef;
+        this.targetFound = targetFound;
+        this.parentPath = parentPath;
     }
 }
 exports.MissingPointerError = MissingPointerError;

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

@@ -18,7 +18,7 @@ export declare function filter(plugins: Plugin[], method: any, file: any): Plugi
  * Sorts the given plugins, in place, by their `order` property.
  */
 export declare function sort(plugins: Plugin[]): Plugin[];
-export interface PluginResult<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+export interface PluginResult<S extends object = JSONSchema> {
     plugin: Plugin;
     result?: string | Buffer | S;
     error?: any;
@@ -31,4 +31,4 @@ export interface PluginResult<S extends object = JSONSchema, O extends ParserOpt
  * If the promise rejects, or the callback is called with an error, then the next plugin is called.
  * If ALL plugins fail, then the last error is thrown.
  */
-export declare function run<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions<S>, file: FileInfo, $refs: $Refs<S, O>): Promise<PluginResult<S, O>>;
+export declare function run<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions<S>, file: FileInfo, $refs: $Refs<S, O>): Promise<PluginResult<S>>;

package/dist/lib/util/url.js

@@ -73,10 +73,11 @@ exports.parse = parse;
  * @returns
  */
 function resolve(from, to) {
-    const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "resolve://");
+    // we use a non-existent URL to check if its a relative URL
+    const fromUrl = new URL((0, convert_path_to_posix_1.default)(from), "https://aaa.nonexistanturl.com");
     const resolvedUrl = new URL((0, convert_path_to_posix_1.default)(to), fromUrl);
     const endSpaces = to.match(/(\s*)$/)?.[1] || "";
-    if (resolvedUrl.protocol === "resolve:") {
+    if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
         // `from` is a relative URL.
         const { pathname, search, hash } = resolvedUrl;
         return pathname + search + hash + endSpaces;

package/lib/dereference.ts

@@ -123,7 +123,31 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
             circular = dereferenced.circular;
             // Avoid pointless mutations; breaks frozen objects to no profit
             if (obj[key] !== dereferenced.value) {
+              // If we have properties we want to preserve from our dereferenced schema then we need
+              // to copy them over to our new object.
+              const preserved: Map<string, unknown> = new Map();
+              if (derefOptions?.preservedProperties) {
+                if (typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+                  derefOptions?.preservedProperties.forEach((prop) => {
+                    if (prop in obj[key]) {
+                      preserved.set(prop, obj[key][prop]);
+                    }
+                  });
+                }
+              }
+
               obj[key] = dereferenced.value;
+
+              // If we have data to preserve and our dereferenced object is still an object then
+              // we need copy back our preserved data into our dereferenced schema.
+              if (derefOptions?.preservedProperties) {
+                if (preserved.size && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+                  preserved.forEach((value, prop) => {
+                    obj[key][prop] = value;
+                  });
+                }
+              }
+
               derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
             }
           } else {
@@ -272,7 +296,8 @@ function dereference$Ref<S extends object = JSONSchema, O extends ParserOptions<
 
 /**
  * Called when a circular reference is found.
- * It sets the {@link $Refs#circular} flag, and throws an error if options.dereference.circular is false.
+ * It sets the {@link $Refs#circular} flag, executes the options.dereference.onCircular callback,
+ * and throws an error if options.dereference.circular is false.
  *
  * @param keyPath - The JSON Reference path of the circular reference
  * @param $refs
@@ -281,6 +306,8 @@ function dereference$Ref<S extends object = JSONSchema, O extends ParserOptions<
  */
 function foundCircularReference(keyPath: any, $refs: any, options: any) {
   $refs.circular = true;
+  options?.dereference?.onCircular?.(keyPath);
+
   if (!options.dereference.circular) {
     throw ono.reference(`Circular $ref pointer found at ${keyPath}`);
   }

package/lib/index.ts

@@ -144,10 +144,8 @@ export class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S
     }
   }
 
-  public static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-    schema: S | string | unknown,
-  ): Promise<S>;
-  public static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
+  public static parse<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  public static parse<S extends object = JSONSchema>(
     schema: S | string | unknown,
     callback: SchemaCallback<S>,
   ): Promise<void>;
@@ -269,10 +267,8 @@ export class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S
    * @param options (optional)
    * @param callback (optional) A callback that will receive the bundled schema object
    */
-  public static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-    schema: S | string | unknown,
-  ): Promise<S>;
-  public static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
+  public static bundle<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  public static bundle<S extends object = JSONSchema>(
     schema: S | string | unknown,
     callback: SchemaCallback<S>,
   ): Promise<void>;
@@ -343,10 +339,8 @@ export class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S
    * @param options (optional)
    * @param callback (optional) A callback that will receive the dereferenced schema object
    */
-  public static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-    schema: S | string | unknown,
-  ): Promise<S>;
-  public static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
+  public static dereference<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  public static dereference<S extends object = JSONSchema>(
     schema: S | string | unknown,
     callback: SchemaCallback<S>,
   ): Promise<void>;

package/lib/options.ts

@@ -29,6 +29,13 @@ export interface DereferenceOptions {
    */
   excludedPathMatcher?(path: string): boolean;
 
+  /**
+   * Callback invoked during circular reference detection.
+   *
+   * @argument {string} path - The path that is circular (ie. the `$ref` string)
+   */
+  onCircular?(path: string): void;
+
   /**
    * Callback invoked during dereferencing.
    *
@@ -39,6 +46,16 @@ export interface DereferenceOptions {
    */
   onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
 
+  /**
+   * An array of properties to preserve when dereferencing a `$ref` schema. Useful if you want to
+   * enforce non-standard dereferencing behavior like present in the OpenAPI 3.1 specification where
+   * `description` and `summary` properties are preserved when alongside a `$ref` pointer.
+   *
+   * If none supplied then no properties will be preserved and the object will be fully replaced
+   * with the dereferenced `$ref`.
+   */
+  preservedProperties?: string[];
+
   /**
    * Whether a reference should resolve relative to its directory/path, or from the cwd
    *

package/lib/pointer.ts

@@ -88,6 +88,7 @@ class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = Parser
    */
   resolve(obj: S, options?: O, pathFromRoot?: string) {
     const tokens = Pointer.parse(this.path, this.originalPath);
+    const found: any = [];
 
     // Crawl the object, one token at a time
     this.value = unwrapOrThrow(obj);
@@ -103,6 +104,7 @@ class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = Parser
       }
 
       const token = tokens[i];
+
       if (this.value[token] === undefined || (this.value[token] === null && i === tokens.length - 1)) {
         // one final case is if the entry itself includes slashes, and was parsed out as a token - we can join the remaining tokens and try again
         let didFindSubstringSlashMatch = false;
@@ -120,10 +122,19 @@ class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = Parser
         }
 
         this.value = null;
-        throw new MissingPointerError(token, decodeURI(this.originalPath));
+
+        const path = this.$ref.path || "";
+
+        const targetRef = this.path.replace(path, "");
+        const targetFound = Pointer.join("", found);
+        const parentPath = pathFromRoot?.replace(path, "");
+
+        throw new MissingPointerError(token, decodeURI(this.originalPath), targetRef, targetFound, parentPath);
       } else {
         this.value = this.value[token];
       }
+
+      found.push(token);
     }
 
     // Resolve the final value

package/lib/util/errors.ts

@@ -123,8 +123,17 @@ export class UnmatchedResolverError extends JSONParserError {
 export class MissingPointerError extends JSONParserError {
   code = "EMISSINGPOINTER" as JSONParserErrorType;
   name = "MissingPointerError";
-  constructor(token: string, path: string) {
+  public targetToken: any;
+  public targetRef: string;
+  public targetFound: string;
+  public parentPath: string;
+  constructor(token: any, path: any, targetRef: any, targetFound: any, parentPath: any) {
     super(`Missing $ref pointer "${getHash(path)}". Token "${token}" does not exist.`, stripHash(path));
+
+    this.targetToken = token;
+    this.targetRef = targetRef;
+    this.targetFound = targetFound;
+    this.parentPath = parentPath;
   }
 }
 

package/lib/util/plugins.ts

@@ -45,8 +45,7 @@ export function sort(plugins: Plugin[]) {
   });
 }
 
-// @ts-ignore
-export interface PluginResult<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+export interface PluginResult<S extends object = JSONSchema> {
   plugin: Plugin;
   result?: string | Buffer | S;
   error?: any;
@@ -67,10 +66,10 @@ export async function run<S extends object = JSONSchema, O extends ParserOptions
   $refs: $Refs<S, O>,
 ) {
   let plugin: Plugin;
-  let lastError: PluginResult<S, O>;
+  let lastError: PluginResult<S>;
   let index = 0;
 
-  return new Promise<PluginResult<S, O>>((resolve, reject) => {
+  return new Promise<PluginResult<S>>((resolve, reject) => {
     runNextPlugin();
 
     function runNextPlugin() {
@@ -97,7 +96,7 @@ export async function run<S extends object = JSONSchema, O extends ParserOptions
       }
     }
 
-    function callback(err: PluginResult<S, O>["error"], result: PluginResult<S, O>["result"]) {
+    function callback(err: PluginResult<S>["error"], result: PluginResult<S>["result"]) {
       if (err) {
         onError(err);
       } else {
@@ -105,7 +104,7 @@ export async function run<S extends object = JSONSchema, O extends ParserOptions
       }
     }
 
-    function onSuccess(result: PluginResult<S, O>["result"]) {
+    function onSuccess(result: PluginResult<S>["result"]) {
       // console.log('    success');
       resolve({
         plugin,
@@ -113,7 +112,7 @@ export async function run<S extends object = JSONSchema, O extends ParserOptions
       });
     }
 
-    function onError(error: PluginResult<S, O>["error"]) {
+    function onError(error: PluginResult<S>["error"]) {
       // console.log('    %s', err.message || err);
       lastError = {
         plugin,

package/lib/util/url.ts

@@ -26,10 +26,11 @@ export const parse = (u: string | URL) => new URL(u);
  * @returns
  */
 export function resolve(from: string, to: string) {
-  const fromUrl = new URL(convertPathToPosix(from), "resolve://");
+  // we use a non-existent URL to check if its a relative URL
+  const fromUrl = new URL(convertPathToPosix(from), "https://aaa.nonexistanturl.com");
   const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
   const endSpaces = to.match(/(\s*)$/)?.[1] || "";
-  if (resolvedUrl.protocol === "resolve:") {
+  if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
     // `from` is a relative URL.
     const { pathname, search, hash } = resolvedUrl;
     return pathname + search + hash + endSpaces;

package/package.json

@@ -1,7 +1,19 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "11.7.3",
+  "version": "11.9.0",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
+  "scripts": {
+    "prepublishOnly": "yarn build",
+    "lint": "eslint lib",
+    "build": "rimraf dist && tsc",
+    "typecheck": "tsc --noEmit",
+    "prettier": "prettier --write \"**/*.+(js|jsx|ts|tsx|har||json|css|md)\"",
+    "test": "vitest --coverage",
+    "test:node": "yarn test",
+    "test:browser": "cross-env BROWSER=\"true\" yarn test",
+    "test:update": "vitest -u",
+    "test:watch": "vitest -w"
+  },
   "keywords": [
     "json",
     "schema",
@@ -54,42 +66,30 @@
     "dist",
     "cjs"
   ],
-  "scripts": {
-    "prepublishOnly": "yarn build",
-    "lint": "eslint lib",
-    "build": "rimraf dist && tsc",
-    "typecheck": "tsc --noEmit",
-    "prettier": "prettier --write \"**/*.+(js|jsx|ts|tsx|har||json|css|md)\"",
-    "test": "vitest --coverage",
-    "test:node": "yarn test",
-    "test:browser": "cross-env BROWSER=\"true\" yarn test",
-    "test:update": "vitest -u",
-    "test:watch": "vitest -w"
-  },
   "devDependencies": {
-    "@eslint/compat": "^1.2.4",
-    "@eslint/js": "^9.16.0",
-    "@types/eslint": "9.6.1",
+    "@eslint/compat": "^1.2.5",
+    "@eslint/js": "^9.18.0",
+    "@types/eslint": "^9.6.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22",
-    "@typescript-eslint/eslint-plugin": "^8.17.0",
-    "@typescript-eslint/parser": "^8.17.0",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "@vitest/coverage-v8": "^3.0.4",
     "cross-env": "^7.0.3",
-    "eslint": "^9.16.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-prettier": "^5.2.3",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-unused-imports": "^4.1.4",
-    "globals": "^15.13.0",
-    "jsdom": "^25.0.1",
+    "globals": "^15.14.0",
+    "jsdom": "^26.0.0",
     "prettier": "^3.4.2",
     "rimraf": "^6.0.1",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.17.0",
-    "vitest": "^2.1.8"
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.21.0",
+    "vitest": "^3.0.4"
   },
   "dependencies": {
     "@jsdevtools/ono": "^7.1.3",