@nocobase/plugin-mcp-server 2.1.0-alpha.16 → 2.1.0-alpha.17

package/dist/externalVersion.js

@@ -8,10 +8,10 @@
  */
 
 module.exports = {
-  "@nocobase/flow-engine": "2.1.0-alpha.16",
-  "@nocobase/client": "2.1.0-alpha.16",
-  "@nocobase/ai": "2.1.0-alpha.16",
-  "@nocobase/server": "2.1.0-alpha.16",
-  "@nocobase/utils": "2.1.0-alpha.16",
-  "@nocobase/plugin-idp-oauth": "2.1.0-alpha.16"
+  "@nocobase/flow-engine": "2.1.0-alpha.17",
+  "@nocobase/client": "2.1.0-alpha.17",
+  "@nocobase/ai": "2.1.0-alpha.17",
+  "@nocobase/server": "2.1.0-alpha.17",
+  "@nocobase/utils": "2.1.0-alpha.17",
+  "@nocobase/plugin-idp-oauth": "2.1.0-alpha.17"
 };

package/dist/node_modules/@apidevtools/json-schema-ref-parser/README.md

@@ -57,12 +57,12 @@ JavaScript objects.
 
 - Use **JSON** or **YAML** schemas — or even a mix of both!
 - Supports `$ref` pointers to external files and URLs, as well
-  as [custom sources](https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html) such as databases
-- Can [bundle](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundlepath-options-callback) multiple
+  as [custom sources](https://apidevtools.com/json-schema-ref-parser/docs/plugins/resolvers.html) such as databases
+- Can [bundle](https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundlepath-options-callback) multiple
   files into a single schema that only has _internal_ `$ref` pointers
-- Can [dereference](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback)
+- Can [dereference](https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback)
   your schema, producing a plain-old JavaScript object that's easy to work with
-- Supports [circular references](https://apitools.dev/json-schema-ref-parser/docs/#circular-refs), nested references,
+- Supports [circular references](https://apidevtools.com/json-schema-ref-parser/docs/#circular-refs), nested references,
   back-references, and cross-references between files
 - Maintains object reference equality — `$ref` pointers to the same value always resolve to the same object
   instance
@@ -86,7 +86,7 @@ try {
 }
 ```
 
-For more detailed examples, please see the [API Documentation](https://apitools.dev/json-schema-ref-parser/docs/)
+For more detailed examples, please see the [API Documentation](https://apidevtools.com/json-schema-ref-parser/docs/)
 
 ## Polyfills
 
@@ -130,7 +130,7 @@ config.plugins.push(
 
 ## API Documentation
 
-Full API documentation is available [right here](https://apitools.dev/json-schema-ref-parser/docs/)
+Full API documentation is available [right here](https://apidevtools.com/json-schema-ref-parser/docs/)
 
 ## Contributing
 
@@ -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/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -70,10 +80,10 @@ function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs,
             const keys = Object.keys(obj).sort((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") {
+                if (a === "definitions" || a === "$defs") {
                     return -1;
                 }
-                else if (b === "definitions") {
+                else if (b === "definitions" || b === "$defs") {
                     return 1;
                 }
                 else {
@@ -204,8 +214,8 @@ function remap(inventory) {
         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.
-            const aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-            const bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+            const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
+            const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
             if (aDefinitionsIndex !== bDefinitionsIndex) {
                 // Give higher priority to the $ref that's closer to the "definitions" property
                 return bDefinitionsIndex - aDefinitionsIndex;

package/dist/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/dereference.js

@@ -15,20 +15,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ref_js_1 = __importDefault(require("./ref.js"));
 const pointer_js_1 = __importDefault(require("./pointer.js"));
-const ono_1 = require("@jsdevtools/ono");
 const url = __importStar(require("./util/url.js"));
 const errors_1 = require("./util/errors");
 exports.default = dereference;
@@ -66,11 +75,7 @@ function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedC
         value: obj,
         circular: false,
     };
-    if (options && options.timeoutMs) {
-        if (Date.now() - startTime > options.timeoutMs) {
-            throw new errors_1.TimeoutError(options.timeoutMs);
-        }
-    }
+    checkDereferenceTimeout(startTime, options);
     const derefOptions = (options.dereference || {});
     const isExcludedPath = derefOptions.excludedPathMatcher || (() => false);
     if (derefOptions?.circular === "ignore" || !processedObjects.has(obj)) {
@@ -84,6 +89,7 @@ function crawl(obj, path, pathFromRoot, parents, processedObjects, dereferencedC
             }
             else {
                 for (const key of Object.keys(obj)) {
+                    checkDereferenceTimeout(startTime, options);
                     const keyPath = pointer_js_1.default.join(path, key);
                     const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
                     if (isExcludedPath(keyPathFromRoot)) {
@@ -96,7 +102,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);
                         }
                     }
@@ -140,22 +167,52 @@ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, de
     const shouldResolveOnCwd = isExternalRef && options?.dereference?.externalReferenceResolution === "root";
     const $refPath = url.resolve(shouldResolveOnCwd ? url.cwd() : path, $ref.$ref);
     const cache = dereferencedCache.get($refPath);
-    if (cache && !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 (cache) {
+        // If the object we found is circular we can immediately return it because it would have been
+        // cached with everything we need already and we don't need to re-process anything inside it.
+        //
+        // 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];
+                    }
                 }
+                return {
+                    circular: cache.circular,
+                    value: Object.assign({}, cache.value, extraKeys),
+                };
+            }
+            return cache;
+        }
+        // If both our cached value and our incoming `$ref` are the same then we can return what we
+        // got out of the cache, otherwise we should re-process this value. We need to do this because
+        // the current dereference caching mechanism doesn't take into account that `$ref` are neither
+        // unique or reference the same file.
+        //
+        // For example if `schema.yaml` references `definitions/child.yaml` and
+        // `definitions/parent.yaml` references `child.yaml` then `$ref: 'child.yaml'` may get cached
+        // for `definitions/child.yaml`, resulting in `schema.yaml` being having an invalid reference
+        // to `child.yaml`.
+        //
+        // This check is not perfect and the design of the dereference caching mechanism needs a total
+        // overhaul.
+        if (typeof cache.value === "object" && "$ref" in cache.value && "$ref" in $ref) {
+            if (cache.value.$ref === $ref.$ref) {
+                return cache;
+            }
+            else {
+                // no-op
             }
-            return {
-                circular: cache.circular,
-                value: Object.assign({}, cache.value, extraKeys),
-            };
         }
-        return cache;
+        else {
+            return cache;
+        }
     }
     const pointer = $refs._resolve($refPath, path, options);
     if (pointer === null) {
@@ -198,9 +255,23 @@ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, de
     }
     return dereferencedObject;
 }
+/**
+ * Check if we've run past our allowed timeout and throw an error if we have.
+ *
+ * @param startTime - The time when the dereferencing started.
+ * @param options
+ */
+function checkDereferenceTimeout(startTime, options) {
+    if (options && options.timeoutMs) {
+        if (Date.now() - startTime > options.timeoutMs) {
+            throw new errors_1.TimeoutError(options.timeoutMs);
+        }
+    }
+}
 /**
  * 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
@@ -209,8 +280,10 @@ 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}`);
+        const error = new ReferenceError(`Circular $ref pointer found at ${keyPath}`);
+        throw error;
     }
     return true;
 }

package/dist/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.d.ts

@@ -5,6 +5,7 @@ import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverErro
 import type { ParserOptions } from "./options.js";
 import { getJsonSchemaRefParserDefaultOptions } from "./options.js";
 import type { $RefsCallback, JSONSchema, SchemaCallback, FileInfo, Plugin, ResolverOptions, HTTPResolverOptions } from "./types/index.js";
+import { isUnsafeUrl } from "./util/url.js";
 export type RefParserSchema = string | JSONSchema;
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
@@ -42,20 +43,20 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
     parse(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
     parse(schema: S | string | unknown, options: O): Promise<S>;
     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>;
+    parse(path: string, schema: S | string | unknown, options: O): Promise<S>;
+    parse(path: string, schema: S | string | unknown, options: O, 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>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(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>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     /**
      * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
      *
      * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
      *
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @param options (optional)
@@ -65,14 +66,14 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
     resolve(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
     resolve(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
     resolve(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-    resolve(baseUrl: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-    resolve(baseUrl: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+    resolve(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+    resolve(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
     /**
      * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
      *
      * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
      *
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @param options (optional)
@@ -82,31 +83,31 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
     static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
     static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
     static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-    static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-    static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+    static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+    static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
     /**
      * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
      *
      * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
      *
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @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>;
-    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<S>;
+    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<S>;
     /**
      * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
      *
      * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
      *
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @param options (optional)
@@ -116,41 +117,41 @@ export declare class $RefParser<S extends object = JSONSchema, O extends ParserO
     bundle(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
     bundle(schema: S | string | unknown, options: O): Promise<S>;
     bundle(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-    bundle(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    bundle(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+    bundle(path: string, schema: S | string | unknown, options: O): Promise<S>;
+    bundle(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     /**
      * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
      *
      * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
      *
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @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>;
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     /**
      * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
      *
      * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
      *
-     * See https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+     * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
      *
-     * @param baseUrl
+     * @param path
      * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
      * @param options (optional)
      * @param callback (optional) A callback that will receive the dereferenced schema object
      */
-    dereference(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+    dereference(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     dereference(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
     dereference(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-    dereference(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
+    dereference(path: string, schema: S | string | unknown, options: O): Promise<S>;
     dereference(schema: S | string | unknown, options: O): Promise<S>;
     dereference(schema: S | string | unknown): Promise<S>;
 }
@@ -159,4 +160,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, FileInfo, Plugin, ResolverOptions, HTTPResolverOptions, _dereference as dereferenceInternal, normalizeArgs as jsonSchemaParserNormalizeArgs, getJsonSchemaRefParserDefaultOptions, };
+export { UnmatchedResolverError, JSONParserError, JSONSchema, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, ParserOptions, $RefsCallback, isHandledError, JSONParserErrorGroup, SchemaCallback, FileInfo, Plugin, ResolverOptions, HTTPResolverOptions, _dereference as dereferenceInternal, normalizeArgs as jsonSchemaParserNormalizeArgs, getJsonSchemaRefParserDefaultOptions, $Refs, isUnsafeUrl, };

package/dist/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js

@@ -15,19 +15,30 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsonSchemaRefParserDefaultOptions = exports.jsonSchemaParserNormalizeArgs = exports.dereferenceInternal = 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;
+exports.isUnsafeUrl = exports.$Refs = exports.getJsonSchemaRefParserDefaultOptions = exports.jsonSchemaParserNormalizeArgs = exports.dereferenceInternal = 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"));
+exports.$Refs = refs_js_1.default;
 const parse_js_1 = __importDefault(require("./parse.js"));
 const normalize_args_js_1 = __importDefault(require("./normalize-args.js"));
 exports.jsonSchemaParserNormalizeArgs = normalize_args_js_1.default;
@@ -46,10 +57,11 @@ Object.defineProperty(exports, "UnmatchedParserError", { enumerable: true, get:
 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"));
 const options_js_1 = require("./options.js");
 Object.defineProperty(exports, "getJsonSchemaRefParserDefaultOptions", { enumerable: true, get: function () { return options_js_1.getJsonSchemaRefParserDefaultOptions; } });
+const url_js_1 = require("./util/url.js");
+Object.defineProperty(exports, "isUnsafeUrl", { enumerable: true, get: function () { return url_js_1.isUnsafeUrl; } });
 /**
  * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
  * and provides methods for traversing, manipulating, and dereferencing those references.
@@ -77,7 +89,7 @@ class $RefParser {
         const args = (0, normalize_args_js_1.default)(arguments);
         let promise;
         if (!args.path && !args.schema) {
-            const err = (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
+            const err = new Error(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
             return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
         }
         // Reset everything
@@ -126,7 +138,7 @@ class $RefParser {
                 return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
             }
             else {
-                throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
+                throw new SyntaxError(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
             }
         }
         catch (err) {