Initial commit

node_modules/@apidevtools/swagger-parser/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 James Messinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@apidevtools/swagger-parser/README.md

@@ -0,0 +1,146 @@
+Swagger 2.0 and OpenAPI 3.0 parser/validator
+============================
+
+[![Build Status](https://github.com/APIDevTools/swagger-parser/workflows/CI-CD/badge.svg?branch=master)](https://github.com/APIDevTools/swagger-parser/actions)
+[![Coverage Status](https://coveralls.io/repos/github/APIDevTools/swagger-parser/badge.svg?branch=master)](https://coveralls.io/github/APIDevTools/swagger-parser)
+[![Tested on APIs.guru](https://api.apis.guru/badges/tested_on.svg)](https://apis.guru/browse-apis/)
+
+[![npm](https://img.shields.io/npm/v/@apidevtools/swagger-parser.svg)](https://www.npmjs.com/package/@apidevtools/swagger-parser)
+[![Dependencies](https://david-dm.org/APIDevTools/swagger-parser.svg)](https://david-dm.org/APIDevTools/swagger-parser)
+[![License](https://img.shields.io/npm/l/@apidevtools/swagger-parser.svg)](LICENSE)
+[![Buy us a tree](https://img.shields.io/badge/Treeware-%F0%9F%8C%B3-lightgreen)](https://plant.treeware.earth/APIDevTools/swagger-parser)
+
+[![OS and Browser Compatibility](https://apitools.dev/img/badges/ci-badges-with-ie.svg)](https://github.com/APIDevTools/swagger-parser/actions)
+
+[![Online Demo](https://apitools.dev/swagger-parser/online/img/demo.svg)](https://apitools.dev/swagger-parser/online/)
+
+
+
+Features
+--------------------------
+- Parses Swagger specs in **JSON** or **YAML** format
+- Validates against the [Swagger 2.0 schema](https://github.com/OAI/OpenAPI-Specification/blob/master/schemas/v2.0/schema.json) or [OpenAPI 3.0 Schema](https://github.com/OAI/OpenAPI-Specification/blob/master/schemas/v3.0/schema.json)
+- [Resolves](https://apitools.dev/swagger-parser/docs/swagger-parser.html#resolveapi-options-callback) all `$ref` pointers, including external files and URLs
+- Can [bundle](https://apitools.dev/swagger-parser/docs/swagger-parser.html#bundleapi-options-callback) all your Swagger files into a single file that only has _internal_ `$ref` pointers
+- Can [dereference](https://apitools.dev/swagger-parser/docs/swagger-parser.html#dereferenceapi-options-callback) all `$ref` pointers, giving you a normal JavaScript object that's easy to work with
+- **[Tested](https://github.com/APIDevTools/swagger-parser/actions)** in Node.js and all modern web browsers on Mac, Windows, and Linux
+- Tested on **[over 1,500 real-world APIs](https://apis.guru/browse-apis/)** from Google, Microsoft, Facebook, Spotify, etc.
+- Supports [circular references](https://apitools.dev/swagger-parser/docs/#circular-refs), nested references, back-references, and cross-references
+- Maintains object reference equality — `$ref` pointers to the same value always resolve to the same object instance
+
+
+
+Related Projects
+--------------------------
+- [Swagger CLI](https://github.com/APIDevTools/swagger-cli)
+- [Swagger Express Middleware](https://github.com/APIDevTools/swagger-express-middleware)
+
+
+
+Example
+--------------------------
+
+```javascript
+SwaggerParser.validate(myAPI, (err, api) => {
+  if (err) {
+    console.error(err);
+  }
+  else {
+    console.log("API name: %s, Version: %s", api.info.title, api.info.version);
+  }
+});
+```
+
+Or use `async`/`await` or [Promise](http://javascriptplayground.com/blog/2015/02/promises/) syntax instead. The following example is the same as above:
+
+```javascript
+try {
+  let api = await SwaggerParser.validate(myAPI);
+  console.log("API name: %s, Version: %s", api.info.title, api.info.version);
+}
+catch(err) {
+  console.error(err);
+}
+```
+
+For more detailed examples, please see the [API Documentation](https://apitools.dev/swagger-parser/docs/)
+
+
+
+Installation
+--------------------------
+Install using [npm](https://docs.npmjs.com/about-npm/):
+
+```bash
+npm install @apidevtools/swagger-parser
+```
+
+
+
+Usage
+--------------------------
+When using Swagger Parser in Node.js apps, you'll probably want to use **CommonJS** syntax:
+
+```javascript
+const SwaggerParser = require("@apidevtools/swagger-parser");
+```
+
+When using a transpiler such as [Babel](https://babeljs.io/) or [TypeScript](https://www.typescriptlang.org/), or a bundler such as [Webpack](https://webpack.js.org/) or [Rollup](https://rollupjs.org/), you can use **ECMAScript modules** syntax instead:
+
+```javascript
+import * as SwaggerParser from '@apidevtools/swagger-parser';
+```
+
+
+
+Browser support
+--------------------------
+Swagger Parser supports recent versions of every major web browser.  Older browsers may require [Babel](https://babeljs.io/) and/or [polyfills](https://babeljs.io/docs/en/next/babel-polyfill).
+
+To use Swagger Parser in a browser, you'll need to use a bundling tool such as [Webpack](https://webpack.js.org/), [Rollup](https://rollupjs.org/), [Parcel](https://parceljs.org/), or [Browserify](http://browserify.org/). Some bundlers may require a bit of configuration, such as setting `browser: true` in [rollup-plugin-resolve](https://github.com/rollup/rollup-plugin-node-resolve).
+
+
+
+API Documentation
+--------------------------
+Full API documentation is available [right here](https://apitools.dev/swagger-parser/docs/)
+
+
+
+Contributing
+--------------------------
+I welcome any contributions, enhancements, and bug-fixes.  [Open an issue](https://github.com/APIDevTools/swagger-parser/issues) on GitHub and [submit a pull request](https://github.com/APIDevTools/swagger-parser/pulls).
+
+#### Building/Testing
+To build/test the project locally on your computer:
+
+1. __Clone this repo__<br>
+`git clone https://github.com/APIDevTools/swagger-parser.git`
+
+2. __Install dependencies__<br>
+`npm install`
+
+3. __Run the build script__<br>
+`npm run build`
+
+4. __Run the tests__<br>
+`npm test`
+
+5. __Check the code coverage__<br>
+`npm run coverage`
+
+License
+--------------------------
+Swagger 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/swagger-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.
+
+
+
+Big Thanks To
+--------------------------
+Thanks to these awesome companies for their support of Open Source developers ❤
+
+[![GitHub](https://apitools.dev/img/badges/github.svg)](https://github.com/open-source)
+[![NPM](https://apitools.dev/img/badges/npm.svg)](https://www.npmjs.com/)
+[![Coveralls](https://apitools.dev/img/badges/coveralls.svg)](https://coveralls.io)

node_modules/@apidevtools/swagger-parser/lib/index.d.ts

@@ -0,0 +1,439 @@
+import { OpenAPI } from "openapi-types";
+
+export = SwaggerParser;
+
+/**
+ * This is the default export of Swagger Parser. You can creates instances of this class using new SwaggerParser(), or you can just call its static methods.
+ *
+ * See https://apitools.dev/swagger-parser/docs/swagger-parser.html
+ */
+declare class SwaggerParser {
+
+  /**
+   * The `api` property is the parsed/bundled/dereferenced OpenAPI definition. This is the same value that is passed to the callback function (or Promise) when calling the parse, bundle, or dereference methods.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#api
+   */
+  public api: OpenAPI.Document;
+
+  /**
+   * The $refs property is a `$Refs` object, which lets you access all of the externally-referenced files in the OpenAPI definition, as well as easily get and set specific values in the OpenAPI definition using JSON pointers.
+   *
+   * This is the same value that is passed to the callback function (or Promise) when calling the `resolve` method.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#refs
+   */
+  public $refs: SwaggerParser.$Refs;
+
+  /**
+   * Parses, dereferences, and validates the given Swagger API.
+   * Depending on the options, validation can include JSON Schema validation and/or Swagger Spec validation.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#validateapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced OpenAPI definition
+   */
+  public validate(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public validate(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public validate(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public validate(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public validate(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public validate(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * Parses, dereferences, and validates the given Swagger API.
+   * Depending on the options, validation can include JSON Schema validation and/or Swagger Spec validation.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#validateapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced OpenAPI definition
+   */
+  public static validate(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public static validate(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static validate(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static validate(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public static validate(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public static validate(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * Dereferences all `$ref` pointers in the OpenAPI definition, replacing each reference with its resolved value. This results in an API definition 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 API definition using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#dereferenceapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced OpenAPI definition
+   */
+  public dereference(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public dereference(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public dereference(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public dereference(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public dereference(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public dereference(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * Dereferences all `$ref` pointers in the OpenAPI definition, replacing each reference with its resolved value. This results in an API definition 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 API definition using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#dereferenceapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced OpenAPI definition
+   */
+  public static dereference(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public static dereference(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static dereference(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static dereference(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public static dereference(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public static dereference(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * Bundles all referenced files/URLs into a single API definition that only has internal `$ref` pointers. This lets you split-up your API definition however you want while you're building it, but easily combine all those files together when it's time to package or distribute the API definition to other people. The resulting API definition 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 API definition can be safely serialized using `JSON.stringify()`.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#bundleapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the bundled API definition object
+   */
+  public bundle(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public bundle(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public bundle(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public bundle(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public bundle(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public bundle(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * Bundles all referenced files/URLs into a single API definition that only has internal `$ref` pointers. This lets you split-up your API definition however you want while you're building it, but easily combine all those files together when it's time to package or distribute the API definition to other people. The resulting API definition 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 API definition can be safely serialized using `JSON.stringify()`.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#bundleapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the bundled API definition object
+   */
+  public static bundle(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public static bundle(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static bundle(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static bundle(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public static bundle(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public static bundle(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
+   *
+   * Parses the given OpenAPI definition file (in JSON or YAML format), and returns it as a JavaScript object. This method `does not` resolve `$ref` pointers or dereference anything. It simply parses one file and returns it.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#parseapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. The path can be absolute or relative. In Node, the path is relative to `process.cwd()`. In the browser, it's relative to the URL of the page.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the parsed OpenAPI definition object, or an error
+   */
+  public parse(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public parse(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public parse(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public parse(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public parse(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public parse(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
+   *
+   * Parses the given OpenAPI definition file (in JSON or YAML format), and returns it as a JavaScript object. This method `does not` resolve `$ref` pointers or dereference anything. It simply parses one file and returns it.
+   *
+   * See https://apitools.dev/swagger-parser/docs/swagger-parser.html#parseapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. The path can be absolute or relative. In Node, the path is relative to `process.cwd()`. In the browser, it's relative to the URL of the page.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the parsed OpenAPI definition object, or an error
+   */
+  public static parse(api: string | OpenAPI.Document, callback: SwaggerParser.ApiCallback): void;
+  public static parse(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static parse(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.ApiCallback): void;
+  public static parse(api: string | OpenAPI.Document): Promise<OpenAPI.Document>;
+  public static parse(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+  public static parse(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<OpenAPI.Document>;
+
+  /**
+   * *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 OpenAPI definition 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/swagger-parser/docs/swagger-parser.html#resolveapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive a `$Refs` object
+   */
+  public resolve(api: string | OpenAPI.Document, callback: SwaggerParser.$RefsCallback): void;
+  public resolve(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.$RefsCallback): void;
+  public resolve(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.$RefsCallback): void;
+  public resolve(api: string | OpenAPI.Document): Promise<SwaggerParser.$Refs>;
+  public resolve(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<SwaggerParser.$Refs>;
+  public resolve(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<SwaggerParser.$Refs>;
+
+  /**
+   * *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 OpenAPI definition 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/swagger-parser/docs/swagger-parser.html#resolveapi-options-callback
+   *
+   * @param api An OpenAPI definition, or the file path or URL of an OpenAPI definition. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive a `$Refs` object
+   */
+  public static resolve(api: string | OpenAPI.Document, callback: SwaggerParser.$RefsCallback): void;
+  public static resolve(api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.$RefsCallback): void;
+  public static resolve(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options, callback: SwaggerParser.$RefsCallback): void;
+  public static resolve(api: string | OpenAPI.Document): Promise<SwaggerParser.$Refs>;
+  public static resolve(api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<SwaggerParser.$Refs>;
+  public static resolve(baseUrl: string, api: string | OpenAPI.Document, options: SwaggerParser.Options): Promise<SwaggerParser.$Refs>;
+}
+
+// eslint-disable-next-line no-redeclare
+declare namespace SwaggerParser {
+
+  export type ApiCallback = (err: Error | null, api?: OpenAPI.Document) => any;
+  export type $RefsCallback = (err: Error | null, $refs?: $Refs) => any;
+
+  /**
+   * See https://apitools.dev/swagger-parser/docs/options.html
+   */
+  export interface Options {
+
+    /**
+     * The `parse` options determine how different types of files will be parsed.
+     *
+     * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
+     */
+    parse?: {
+      json?: ParserOptions | boolean;
+      yaml?: ParserOptions | boolean;
+      text?: (ParserOptions & { encoding?: string }) | boolean;
+      [key: string]: ParserOptions | boolean | undefined;
+    };
+
+    /**
+     * The `resolve` options control how Swagger Parser will resolve file paths and URLs, and how those files will be read/downloaded.
+     *
+     * JSON Schema `$Ref` Parser comes with built-in support for HTTP and HTTPS, as well as support for local files (when running in Node.js). You can configure or disable either of these built-in resolvers. You can also add your own custom resolvers if you want.
+     */
+    resolve?: {
+
+      /**
+       * Determines whether external $ref pointers will be resolved. If this option is disabled, then external `$ref` pointers will simply be ignored.
+       */
+      external?: boolean;
+      file?: Partial<ResolverOptions> | boolean;
+      http?: HTTPResolverOptions | boolean;
+    };
+
+    /**
+     * The `dereference` options control how JSON Schema `$Ref` Parser will dereference `$ref` pointers within the JSON schema.
+     */
+    dereference?: {
+
+      /**
+       * Determines whether circular `$ref` pointers are handled.
+       *
+       * If set to `false`, then a `ReferenceError` will be thrown if the schema contains any circular references.
+       *
+       * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
+       */
+      circular?: boolean | "ignore";
+    };
+
+    /**
+     * The `validate` options control how Swagger Parser will validate the API.
+     */
+    validate?: {
+
+      /**
+       * If set to `false`, then validating against the Swagger 2.0 Schema or OpenAPI 3.0 Schema is disabled.
+       */
+      schema?: boolean;
+
+      /**
+       * If set to `false`, then validating against the Swagger 2.0 Specification is disabled.
+       */
+      spec?: boolean;
+    };
+  }
+
+  export interface HTTPResolverOptions extends Partial<ResolverOptions> {
+
+    /**
+     * You can specify any HTTP headers that should be sent when downloading files. For example, some servers may require you to set the `Accept` or `Referrer` header.
+     */
+    headers?: object;
+
+    /**
+     * The amount of time (in milliseconds) to wait for a response from the server when downloading files. The default is 5 seconds.
+     */
+    timeout?: number;
+
+    /**
+     * The maximum number of HTTP redirects to follow per file. The default is 5. To disable automatic following of redirects, set this to zero.
+     */
+    redirects?: number;
+
+    /**
+     * Set this to `true` if you're downloading files from a CORS-enabled server that requires authentication
+     */
+    withCredentials?: boolean;
+  }
+
+  /**
+   * JSON Schema `$Ref` Parser comes with built-in resolvers for HTTP and HTTPS URLs, as well as local filesystem paths (when running in Node.js). You can add your own custom resolvers to support additional protocols, or even replace any of the built-in resolvers with your own custom implementation.
+   *
+   * See https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html
+   */
+  export interface ResolverOptions {
+
+    /**
+     * All resolvers have an order property, even the built-in resolvers. If you don't specify an order property, then your resolver will run last. Specifying `order: 1`, like we did in this example, will make your resolver run first. Or you can squeeze your resolver in-between some of the built-in resolvers. For example, `order: 101` would make it run after the file resolver, but before the HTTP resolver. You can see the order of all the built-in resolvers by looking at their source code.
+     *
+     * The order property and canRead property are related to each other. For each file that Swagger Parser needs to resolve, it first determines which resolvers can read that file by checking their canRead property. If only one resolver matches a file, then only that one resolver is called, regardless of its order. If multiple resolvers match a file, then those resolvers are tried in order until one of them successfully reads the file. Once a resolver successfully reads the file, the rest of the resolvers are skipped.
+     */
+    order?: number;
+
+    /**
+     * The `canRead` property tells JSON Schema `$Ref` Parser what kind of files your resolver can read. In this example, we've simply specified a regular expression that matches "mogodb://" URLs, but we could have used a simple boolean, or even a function with custom logic to determine which files to resolve. Here are examples of each approach:
+     */
+    canRead: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
+
+    /**
+     * This is where the real work of a resolver happens. The `read` method accepts the same file info object as the `canRead` function, but rather than returning a boolean value, the `read` method should return the contents of the file. The file contents should be returned in as raw a form as possible, such as a string or a byte array. Any further parsing or processing should be done by parsers.
+     *
+     * Unlike the `canRead` function, the `read` method can also be asynchronous. This might be important if your resolver needs to read data from a database or some other external source. You can return your asynchronous value using either an ES6 Promise or a Node.js-style error-first callback. Of course, if your resolver has the ability to return its data synchronously, then that's fine too. Here are examples of all three approaches:
+     */
+    read(
+      file: FileInfo,
+      callback?: (error: Error | null, data: string | null) => any
+    ): string | Buffer | Promise<string | Buffer>;
+  }
+
+  export interface ParserOptions {
+
+    /**
+     * Parsers run in a specific order, relative to other parsers. For example, a parser with `order: 5` will run before a parser with `order: 10`. If a parser is unable to successfully parse a file, then the next parser is tried, until one succeeds or they all fail.
+     *
+     * You can change the order in which parsers run, which is useful if you know that most of your referenced files will be a certain type, or if you add your own custom parser that you want to run first.
+     */
+    order?: number;
+
+    /**
+     * All of the built-in parsers allow empty files by default. The JSON and YAML parsers will parse empty files as `undefined`. The text parser will parse empty files as an empty string. The binary parser will parse empty files as an empty byte array.
+     *
+     * You can set `allowEmpty: false` on any parser, which will cause an error to be thrown if a file empty.
+     */
+    allowEmpty?: boolean;
+
+    /**
+     * Determines which parsers will be used for which files.
+     *
+     * A regular expression can be used to match files by their full path. A string (or array of strings) can be used to match files by their file extension. Or a function can be used to perform more complex matching logic. See the custom parser docs for details.
+     */
+    canParse?: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
+  }
+
+  /**
+   * JSON Schema `$Ref` Parser supports plug-ins, such as resolvers and parsers. These plug-ins can have methods such as `canRead()`, `read()`, `canParse()`, and `parse()`. All of these methods accept the same object as their parameter: an object containing information about the file being read or parsed.
+   *
+   * The file info object currently only consists of a few properties, but it may grow in the future if plug-ins end up needing more information.
+   *
+   * See https://apitools.dev/json-schema-ref-parser/docs/plugins/file-info-object.html
+   */
+  export interface FileInfo {
+
+    /**
+     * The full URL of the file. This could be any type of URL, including "http://", "https://", "file://", "ftp://", "mongodb://", or even a local filesystem path (when running in Node.js).
+     */
+    url: string;
+
+    /**
+     * The lowercase file extension, such as ".json", ".yaml", ".txt", etc.
+     */
+    extension: string;
+
+    /**
+     * The raw file contents, in whatever form they were returned by the resolver that read the file.
+     */
+    data: string | Buffer;
+  }
+
+  /**
+   * When you call the resolve method, the value that gets passed to the callback function (or Promise) is a $Refs object. This same object is accessible via the parser.$refs property of SwaggerParser objects.
+   *
+   * This object is a map of JSON References and their resolved values. It also has several convenient helper methods that make it easy for you to navigate and manipulate the JSON References.
+   *
+   * See https://apitools.dev/swagger-parser/docs/refs.html
+   */
+  export class $Refs {
+    /**
+     * This property is true if the API definition contains any circular references. You may want to check this property before serializing the dereferenced API definition as JSON, since JSON.stringify() does not support circular references by default.
+     *
+     * See https://apitools.dev/swagger-parser/docs/refs.html#circular
+     */
+    public circular: boolean;
+
+    /**
+     * Returns the paths/URLs of all the files in your API definition (including the main API definition file).
+     *
+     * See https://apitools.dev/swagger-parser/docs/refs.html#pathstypes
+     *
+     * @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
+     */
+    public paths(...types: string[]): string[]
+
+    /**
+     * Returns a map of paths/URLs and their correspond values.
+     *
+     * See https://apitools.dev/swagger-parser/docs/refs.html#valuestypes
+     *
+     * @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
+     */
+    public values(...types: string[]): { [url: string]: any }
+
+    /**
+     * Returns `true` if the given path exists in the OpenAPI definition; otherwise, returns `false`
+     *
+     * See https://apitools.dev/swagger-parser/docs/refs.html#existsref
+     *
+     * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+     */
+    public exists($ref: string): boolean
+
+    /**
+     * Gets the value at the given path in the OpenAPI definition. Throws an error if the path does not exist.
+     *
+     * See https://apitools.dev/swagger-parser/docs/refs.html#getref
+     *
+     * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+     */
+    public get($ref: string): any
+
+    /**
+     * Sets the value at the given path in the OpenAPI definition. If the property, or any of its parents, don't exist, they will be created.
+     *
+     * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+     * @param value The value to assign. Can be anything (object, string, number, etc.)
+     */
+    public set($ref: string, value: any): void
+  }
+
+}

node_modules/@apidevtools/swagger-parser/lib/index.js

@@ -0,0 +1,206 @@
+/* eslint-disable no-unused-vars */
+"use strict";
+
+const validateSchema = require("./validators/schema");
+const validateSpec = require("./validators/spec");
+const { jsonSchemaParserNormalizeArgs: normalizeArgs } = require("@apidevtools/json-schema-ref-parser");
+const util = require("./util");
+const Options = require("./options");
+const maybe = require("call-me-maybe");
+const { ono } = require("@jsdevtools/ono");
+const { $RefParser } = require("@apidevtools/json-schema-ref-parser");
+const { dereferenceInternal: dereference } = require("@apidevtools/json-schema-ref-parser");
+
+const supported31Versions = ["3.1.0", "3.1.1"];
+const supported30Versions = ["3.0.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4"];
+const supportedVersions = [...supported31Versions, ...supported30Versions];
+
+/**
+ * This class parses a Swagger 2.0 or 3.0 API, resolves its JSON references and their resolved values,
+ * and provides methods for traversing, dereferencing, and validating the API.
+ *
+ * @class
+ * @augments $RefParser
+ */
+class SwaggerParser extends $RefParser {
+
+  /**
+   * Parses the given Swagger API.
+   * This method does not resolve any JSON references.
+   * It just reads a single file in JSON or YAML format, and parse it as a JavaScript object.
+   *
+   * @param {string} [path] - The file path or URL of the JSON schema
+   * @param {object} [api] - The Swagger API object. This object will be used instead of reading from `path`.
+   * @param {ParserOptions} [options] - Options that determine how the API is parsed
+   * @param {Function} [callback] - An error-first callback. The second parameter is the parsed API object.
+   * @returns {Promise} - The returned promise resolves with the parsed API object.
+   */
+  async parse (path, api, options, callback) {
+    let args = normalizeArgs(arguments);
+    args.options = new Options(args.options);
+
+    try {
+      let schema = await super.parse(args.path, args.schema, args.options);
+
+      if (schema.swagger) {
+        // Verify that the parsed object is a Swagger API
+        if (schema.swagger === undefined || schema.info === undefined || schema.paths === undefined) {
+          throw ono.syntax(`${args.path || args.schema} is not a valid Swagger API definition`);
+        }
+        else if (typeof schema.swagger === "number") {
+          // This is a very common mistake, so give a helpful error message
+          throw ono.syntax('Swagger version number must be a string (e.g. "2.0") not a number.');
+        }
+        else if (typeof schema.info.version === "number") {
+          // This is a very common mistake, so give a helpful error message
+          throw ono.syntax('API version number must be a string (e.g. "1.0.0") not a number.');
+        }
+        else if (schema.swagger !== "2.0") {
+          throw ono.syntax(`Unrecognized Swagger version: ${schema.swagger}. Expected 2.0`);
+        }
+      }
+      else {
+        // Verify that the parsed object is a Openapi API
+        if (schema.openapi === undefined || schema.info === undefined) {
+          throw ono.syntax(`${args.path || args.schema} is not a valid Openapi API definition`);
+        }
+        else if (schema.paths === undefined) {
+          if (supported31Versions.indexOf(schema.openapi) !== -1) {
+            if (schema.webhooks === undefined) {
+              throw ono.syntax(`${args.path || args.schema} is not a valid Openapi API definition`);
+            }
+          }
+          else {
+            throw ono.syntax(`${args.path || args.schema} is not a valid Openapi API definition`);
+          }
+        }
+        else if (typeof schema.openapi === "number") {
+          // This is a very common mistake, so give a helpful error message
+          throw ono.syntax('Openapi version number must be a string (e.g. "3.0.0") not a number.');
+        }
+        else if (typeof schema.info.version === "number") {
+          // This is a very common mistake, so give a helpful error message
+          throw ono.syntax('API version number must be a string (e.g. "1.0.0") not a number.');
+        }
+        else if (supportedVersions.indexOf(schema.openapi) === -1) {
+          throw ono.syntax(
+            `Unsupported OpenAPI version: ${schema.openapi}. ` +
+            `Swagger Parser only supports versions ${supportedVersions.join(", ")}`
+          );
+        }
+
+        // This is an OpenAPI v3 schema, check if the "servers" have any relative paths and
+        // fix them if the content was pulled from a web resource
+        util.fixOasRelativeServers(schema, args.path);
+      }
+
+      // Looks good!
+      return maybe(args.callback, Promise.resolve(schema));
+    }
+    catch (err) {
+      return maybe(args.callback, Promise.reject(err));
+    }
+  }
+
+  /**
+   * Parses, dereferences, and validates the given Swagger API.
+   * Depending on the options, validation can include JSON Schema validation and/or Swagger Spec validation.
+   *
+   * @param {string} [path] - The file path or URL of the JSON schema
+   * @param {object} [api] - The Swagger API object. This object will be used instead of reading from `path`.
+   * @param {ParserOptions} [options] - Options that determine how the API is parsed, dereferenced, and validated
+   * @param {Function} [callback] - An error-first callback. The second parameter is the parsed API object.
+   * @returns {Promise} - The returned promise resolves with the parsed API object.
+   */
+  async validate (path, api, options, callback) {
+    let me = this;
+    let args = normalizeArgs(arguments);
+    args.options = new Options(args.options);
+
+    // ZSchema doesn't support circular objects, so don't dereference circular $refs yet
+    // (see https://github.com/zaggino/z-schema/issues/137)
+    let circular$RefOption = args.options.dereference.circular;
+    args.options.validate.schema && (args.options.dereference.circular = "ignore");
+
+    try {
+      await this.dereference(args.path, args.schema, args.options);
+
+      // Restore the original options, now that we're done dereferencing
+      args.options.dereference.circular = circular$RefOption;
+
+      if (args.options.validate.schema) {
+        // Validate the API against the Swagger schema
+        // NOTE: This is safe to do, because we haven't dereferenced circular $refs yet
+        validateSchema(me.api);
+
+        if (me.$refs.circular) {
+          if (circular$RefOption === true) {
+            // The API has circular references,
+            // so we need to do a second-pass to fully-dereference it
+            dereference(me, args.options);
+          }
+          else if (circular$RefOption === false) {
+            // The API has circular references, and they're not allowed, so throw an error
+            throw ono.reference("The API contains circular references");
+          }
+        }
+      }
+
+      if (args.options.validate.spec) {
+        // Validate the API against the Swagger spec
+        validateSpec(me.api);
+      }
+
+      return maybe(args.callback, Promise.resolve(me.schema));
+    }
+    catch (err) {
+      return maybe(args.callback, Promise.reject(err));
+    }
+  }
+}
+
+
+/**
+ * Alias {@link $RefParser#schema} as {@link SwaggerParser#api}
+ */
+Object.defineProperty(SwaggerParser.prototype, "api", {
+  configurable: true,
+  enumerable: true,
+  get () {
+    return this.schema;
+  }
+});
+
+/**
+ * The Swagger object
+ * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#swagger-object
+ *
+ * @typedef {{swagger: string, info: {}, paths: {}}} SwaggerObject
+ */
+
+const defaultExport = SwaggerParser;
+
+defaultExport.validate = (...args) => {
+  const defaultInstance = new SwaggerParser();
+  return defaultInstance.validate(...args);
+};
+defaultExport.dereference = (...args) => {
+  const defaultInstance = new SwaggerParser();
+  return defaultInstance.dereference(...args);
+};
+defaultExport.bundle = (...args) => {
+  const defaultInstance = new SwaggerParser();
+  return defaultInstance.bundle(...args);
+};
+defaultExport.parse = (...args) => {
+  const defaultInstance = new SwaggerParser();
+  return defaultInstance.parse(...args);
+};
+defaultExport.resolve = (...args) => {
+  const defaultInstance = new SwaggerParser();
+  return defaultInstance.resolve(...args);
+};
+defaultExport.default = defaultExport;
+defaultExport.SwaggerParser = defaultExport;
+
+module.exports = defaultExport;

node_modules/@apidevtools/swagger-parser/lib/options.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { getJsonSchemaRefParserDefaultOptions } = require("@apidevtools/json-schema-ref-parser");
+const schemaValidator = require("./validators/schema");
+const specValidator = require("./validators/spec");
+
+module.exports = ParserOptions;
+
+
+
+/**
+ * Merges the properties of the source object into the target object.
+ *
+ * @param target - The object that we're populating
+ * @param source - The options that are being merged
+ * @returns
+ */
+function merge (target, source) {
+  if (isMergeable(source)) {
+    // prevent prototype pollution
+    const keys = Object.keys(source).filter((key) => !["__proto__", "constructor", "prototype"].includes(key));
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const sourceSetting = source[key];
+      const targetSetting = target[key];
+
+      if (isMergeable(sourceSetting)) {
+        // It's a nested object, so merge it recursively
+        target[key] = merge(targetSetting || {}, sourceSetting);
+      }
+      else if (sourceSetting !== undefined) {
+        // It's a scalar value, function, or array. No merging necessary. Just overwrite the target value.
+        target[key] = sourceSetting;
+      }
+    }
+  }
+  return target;
+}
+/**
+ * Determines whether the given value can be merged,
+ * or if it is a scalar value that should just override the target value.
+ *
+ * @param val
+ * @returns
+ */
+function isMergeable (val) {
+  return val && typeof val === "object" && !Array.isArray(val) && !(val instanceof RegExp) && !(val instanceof Date);
+}
+
+/**
+ * Options that determine how Swagger APIs are parsed, resolved, dereferenced, and validated.
+ *
+ * @param {object|ParserOptions} [_options] - Overridden options
+ * @class
+ * @augments $RefParserOptions
+ */
+function ParserOptions (_options) {
+  const defaultOptions = getJsonSchemaRefParserDefaultOptions();
+  const options = merge(defaultOptions, ParserOptions.defaults);
+  return merge(options, _options);
+}
+
+ParserOptions.defaults = {
+  /**
+   * Determines how the API definition will be validated.
+   *
+   * You can add additional validators of your own, replace an existing one with
+   * your own implemenation, or disable any validator by setting it to false.
+   */
+  validate: {
+    schema: schemaValidator,
+    spec: specValidator,
+  },
+};

node_modules/@apidevtools/swagger-parser/lib/util.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const util = require("util");
+
+exports.format = util.format;
+exports.inherits = util.inherits;
+const parse = (u) => new URL(u);
+
+/**
+ * Regular Expression that matches Swagger path params.
+ */
+exports.swaggerParamRegExp = /\{([^/}]+)}/g;
+
+/**
+ * List of HTTP verbs used for OperationItem as per the Swagger specification
+ */
+const operationsList = ["get", "post", "put", "delete", "patch", "options", "head", "trace"];
+
+/**
+ * This function takes in a Server object, checks if it has relative path
+ * and then fixes it as per the path url
+ *
+ * @param {object} server - The server object to be fixed
+ * @param {string} path - The path (an http/https url) from where the file was downloaded
+ * @returns {object} - The fixed server object
+ */
+function fixServers (server, path) {
+  // Server url starting with "/" tells that it is not an http(s) url
+  if (server.url && server.url.startsWith("/")) {
+    const inUrl = parse(path);
+    const finalUrl = inUrl.protocol + "//" + inUrl.hostname + server.url;
+    server.url = finalUrl;
+    return server;
+  }
+}
+
+/**
+ * This function helps fix the relative servers in the API definition file
+ * be at root, path or operation's level
+ */
+function fixOasRelativeServers (schema, filePath) {
+  if (schema.openapi && (filePath && (filePath.startsWith("http:") || filePath.startsWith("https:")))) {
+    /**
+     * From OpenAPI v3 spec for Server object's url property: "REQUIRED. A URL to the target host.
+     * This URL supports Server Variables and MAY be relative, to indicate that the host location is relative to the location where
+     * the OpenAPI document is being served."
+     * Further, the spec says that "servers" property can show up at root level, in 'Path Item' object or in 'Operation' object.
+     * However, interpretation of the spec says that relative paths for servers should take into account the hostname that
+     * serves the OpenAPI file.
+     */
+    if (schema.servers) {
+      schema.servers.map(server => fixServers(server, filePath)); // Root level servers array's fixup
+    }
+
+    // Path, Operation, or Webhook level servers array's fixup
+    ["paths", "webhooks"].forEach(component => {
+      Object.keys(schema[component] || []).forEach(path => {
+        const pathItem = schema[component][path];
+        Object.keys(pathItem).forEach(opItem => {
+          if (opItem === "servers") {
+            // servers at pathitem level
+            pathItem[opItem].map(server => fixServers(server, filePath));
+          }
+          else if (operationsList.includes(opItem)) {
+            // servers at operation level
+            if (pathItem[opItem].servers) {
+              pathItem[opItem].servers.map(server => fixServers(server, filePath));
+            }
+          }
+        });
+      });
+    });
+  }
+  else {
+    // Do nothing and return
+  }
+}
+
+exports.fixOasRelativeServers = fixOasRelativeServers;

node_modules/@apidevtools/swagger-parser/lib/validators/schema.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const util = require("../util");
+const { ono } = require("@jsdevtools/ono");
+const AjvDraft4 = require("ajv-draft-04");
+const Ajv = require("ajv/dist/2020");
+const { openapi } = require("@apidevtools/openapi-schemas");
+
+module.exports = validateSchema;
+
+/**
+ * Validates the given Swagger API against the Swagger 2.0 or OpenAPI 3.0 and 3.1 schemas.
+ *
+ * @param {SwaggerObject} api
+ */
+function validateSchema (api) {
+  let ajv;
+
+  // Choose the appropriate schema (Swagger or OpenAPI)
+  let schema;
+
+  if (api.swagger) {
+    schema = openapi.v2;
+    ajv = initializeAjv();
+  }
+  else {
+    if (api.openapi.startsWith("3.1")) {
+      schema = openapi.v31;
+
+      // There's a bug with Ajv in how it handles `$dynamicRef` in the way that it's used within the 3.1 schema so we
+      // need to do some adhoc workarounds.
+      // https://github.com/OAI/OpenAPI-Specification/issues/2689
+      // https://github.com/ajv-validator/ajv/issues/1573
+      const schemaDynamicRef = schema.$defs.schema;
+      delete schemaDynamicRef.$dynamicAnchor;
+
+      schema.$defs.components.properties.schemas.additionalProperties = schemaDynamicRef;
+      schema.$defs.header.dependentSchemas.schema.properties.schema = schemaDynamicRef;
+      schema.$defs["media-type"].properties.schema = schemaDynamicRef;
+      schema.$defs.parameter.properties.schema = schemaDynamicRef;
+
+      ajv = initializeAjv(false);
+    }
+    else {
+      schema = openapi.v3;
+      ajv = initializeAjv();
+    }
+  }
+
+  // Validate against the schema
+  let isValid = ajv.validate(schema, api);
+  if (!isValid) {
+    let err = ajv.errors;
+    let message = "Swagger schema validation failed.\n" + formatAjvError(err);
+    throw ono.syntax(err, { details: err }, message);
+  }
+}
+
+/**
+ * Determines which version of Ajv to load and prepares it for use.
+ *
+ * @param {bool} draft04
+ * @returns {Ajv}
+ */
+function initializeAjv (draft04 = true) {
+  const opts = {
+    allErrors: true,
+    strict: false,
+    validateFormats: false,
+  };
+
+  if (draft04) {
+    return new AjvDraft4(opts);
+  }
+
+  return new Ajv(opts);
+}
+
+/**
+ * Run through a set of Ajv errors and compile them into an error message string.
+ *
+ * @param {object[]}  errors     - The Ajv errors
+ * @param {string}    [indent]   - The whitespace used to indent the error message
+ * @returns {string}
+ */
+function formatAjvError (errors, indent) {
+  indent = indent || "  ";
+  let message = "";
+  for (let error of errors) {
+    message += util.format(`${indent}#${error.instancePath.length ? error.instancePath : "/"} ${error.message}\n`);
+  }
+  return message;
+}

node_modules/@apidevtools/swagger-parser/lib/validators/spec.js

@@ -0,0 +1,352 @@
+"use strict";
+
+const util = require("../util");
+const { ono } = require("@jsdevtools/ono");
+const swaggerMethods = require("@apidevtools/swagger-methods");
+const primitiveTypes = ["array", "boolean", "integer", "number", "string"];
+const schemaTypes = ["array", "boolean", "integer", "number", "string", "object", "null", undefined];
+
+module.exports = validateSpec;
+
+/**
+ * Validates parts of the Swagger 2.0 spec that aren't covered by the Swagger 2.0 JSON Schema.
+ *
+ * @param {SwaggerObject} api
+ */
+function validateSpec (api) {
+  if (api.openapi) {
+    // We don't (yet) support validating against the OpenAPI spec
+    return;
+  }
+
+  let paths = Object.keys(api.paths || {});
+  let operationIds = [];
+  for (let pathName of paths) {
+    let path = api.paths[pathName];
+    let pathId = "/paths" + pathName;
+
+    if (path && pathName.indexOf("/") === 0) {
+      validatePath(api, path, pathId, operationIds);
+    }
+  }
+
+  let definitions = Object.keys(api.definitions || {});
+  for (let definitionName of definitions) {
+    let definition = api.definitions[definitionName];
+    let definitionId = "/definitions/" + definitionName;
+    validateRequiredPropertiesExist(definition, definitionId);
+  }
+}
+
+/**
+ * Validates the given path.
+ *
+ * @param {SwaggerObject} api           - The entire Swagger API object
+ * @param {object}        path          - A Path object, from the Swagger API
+ * @param {string}        pathId        - A value that uniquely identifies the path
+ * @param {string}        operationIds  - An array of collected operationIds found in other paths
+ */
+function validatePath (api, path, pathId, operationIds) {
+  for (let operationName of swaggerMethods) {
+    let operation = path[operationName];
+    let operationId = pathId + "/" + operationName;
+
+    if (operation) {
+      let declaredOperationId = operation.operationId;
+      if (declaredOperationId) {
+        if (operationIds.indexOf(declaredOperationId) === -1) {
+          operationIds.push(declaredOperationId);
+        }
+        else {
+          throw ono.syntax(`Validation failed. Duplicate operation id '${declaredOperationId}'`);
+        }
+      }
+      validateParameters(api, path, pathId, operation, operationId);
+
+      let responses = Object.keys(operation.responses || {});
+      for (let responseName of responses) {
+        let response = operation.responses[responseName];
+        let responseId = operationId + "/responses/" + responseName;
+        validateResponse(responseName, (response || {}), responseId);
+      }
+    }
+  }
+}
+
+/**
+ * Validates the parameters for the given operation.
+ *
+ * @param {SwaggerObject} api           - The entire Swagger API object
+ * @param {object}        path          - A Path object, from the Swagger API
+ * @param {string}        pathId        - A value that uniquely identifies the path
+ * @param {object}        operation     - An Operation object, from the Swagger API
+ * @param {string}        operationId   - A value that uniquely identifies the operation
+ */
+function validateParameters (api, path, pathId, operation, operationId) {
+  let pathParams = path.parameters || [];
+  let operationParams = operation.parameters || [];
+
+  // Check for duplicate path parameters
+  try {
+    checkForDuplicates(pathParams);
+  }
+  catch (e) {
+    throw ono.syntax(e, `Validation failed. ${pathId} has duplicate parameters`);
+  }
+
+  // Check for duplicate operation parameters
+  try {
+    checkForDuplicates(operationParams);
+  }
+  catch (e) {
+    throw ono.syntax(e, `Validation failed. ${operationId} has duplicate parameters`);
+  }
+
+  // Combine the path and operation parameters,
+  // with the operation params taking precedence over the path params
+  let params = pathParams.reduce((combinedParams, value) => {
+    let duplicate = combinedParams.some((param) => {
+      return param.in === value.in && param.name === value.name;
+    });
+    if (!duplicate) {
+      combinedParams.push(value);
+    }
+    return combinedParams;
+  }, operationParams.slice());
+
+  validateBodyParameters(params, operationId);
+  validatePathParameters(params, pathId, operationId);
+  validateParameterTypes(params, api, operation, operationId);
+}
+
+/**
+ * Validates body and formData parameters for the given operation.
+ *
+ * @param   {object[]}  params       -  An array of Parameter objects
+ * @param   {string}    operationId  -  A value that uniquely identifies the operation
+ */
+function validateBodyParameters (params, operationId) {
+  let bodyParams = params.filter((param) => { return param.in === "body"; });
+  let formParams = params.filter((param) => { return param.in === "formData"; });
+
+  // There can only be one "body" parameter
+  if (bodyParams.length > 1) {
+    throw ono.syntax(
+      `Validation failed. ${operationId} has ${bodyParams.length} body parameters. Only one is allowed.`,
+    );
+  }
+  else if (bodyParams.length > 0 && formParams.length > 0) {
+    // "body" params and "formData" params are mutually exclusive
+    throw ono.syntax(
+      `Validation failed. ${operationId} has body parameters and formData parameters. Only one or the other is allowed.`,
+    );
+  }
+}
+
+/**
+ * Validates path parameters for the given path.
+ *
+ * @param   {object[]}  params        - An array of Parameter objects
+ * @param   {string}    pathId        - A value that uniquely identifies the path
+ * @param   {string}    operationId   - A value that uniquely identifies the operation
+ */
+function validatePathParameters (params, pathId, operationId) {
+  // Find all {placeholders} in the path string
+  let placeholders = pathId.match(util.swaggerParamRegExp) || [];
+
+  // Check for duplicates
+  for (let i = 0; i < placeholders.length; i++) {
+    for (let j = i + 1; j < placeholders.length; j++) {
+      if (placeholders[i] === placeholders[j]) {
+        throw ono.syntax(
+          `Validation failed. ${operationId} has multiple path placeholders named ${placeholders[i]}`);
+      }
+    }
+  }
+
+  params = params.filter((param) => { return param.in === "path"; });
+
+  for (let param of params) {
+    if (param.required !== true) {
+      throw ono.syntax(
+        "Validation failed. Path parameters cannot be optional. " +
+        `Set required=true for the "${param.name}" parameter at ${operationId}`,
+      );
+    }
+    let match = placeholders.indexOf("{" + param.name + "}");
+    if (match === -1) {
+      throw ono.syntax(
+        `Validation failed. ${operationId} has a path parameter named "${param.name}", ` +
+        `but there is no corresponding {${param.name}} in the path string`
+      );
+    }
+    placeholders.splice(match, 1);
+  }
+
+  if (placeholders.length > 0) {
+    throw ono.syntax(`Validation failed. ${operationId} is missing path parameter(s) for ${placeholders}`);
+  }
+}
+
+/**
+ * Validates data types of parameters for the given operation.
+ *
+ * @param   {object[]}  params       -  An array of Parameter objects
+ * @param   {object}    api          -  The entire Swagger API object
+ * @param   {object}    operation    -  An Operation object, from the Swagger API
+ * @param   {string}    operationId  -  A value that uniquely identifies the operation
+ */
+function validateParameterTypes (params, api, operation, operationId) {
+  for (let param of params) {
+    let parameterId = operationId + "/parameters/" + param.name;
+    let schema, validTypes;
+
+    switch (param.in) {
+      case "body":
+        schema = param.schema;
+        validTypes = schemaTypes;
+        break;
+      case "formData":
+        schema = param;
+        validTypes = primitiveTypes.concat("file");
+        break;
+      default:
+        schema = param;
+        validTypes = primitiveTypes;
+    }
+
+    validateSchema(schema, parameterId, validTypes);
+    validateRequiredPropertiesExist(schema, parameterId);
+
+    if (schema.type === "file") {
+      // "file" params must consume at least one of these MIME types
+      let formData = /multipart\/(.*\+)?form-data/;
+      let urlEncoded = /application\/(.*\+)?x-www-form-urlencoded/;
+
+      let consumes = operation.consumes || api.consumes || [];
+
+      let hasValidMimeType = consumes.some((consume) => {
+        return formData.test(consume) || urlEncoded.test(consume);
+      });
+
+      if (!hasValidMimeType) {
+        throw ono.syntax(
+          `Validation failed. ${operationId} has a file parameter, so it must consume multipart/form-data ` +
+          "or application/x-www-form-urlencoded",
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Checks the given parameter list for duplicates, and throws an error if found.
+ *
+ * @param   {object[]}  params  - An array of Parameter objects
+ */
+function checkForDuplicates (params) {
+  for (let i = 0; i < params.length - 1; i++) {
+    let outer = params[i];
+    for (let j = i + 1; j < params.length; j++) {
+      let inner = params[j];
+      if (outer.name === inner.name && outer.in === inner.in) {
+        throw ono.syntax(`Validation failed. Found multiple ${outer.in} parameters named "${outer.name}"`);
+      }
+    }
+  }
+}
+
+/**
+ * Validates the given response object.
+ *
+ * @param   {string}    code        -  The HTTP response code (or "default")
+ * @param   {object}    response    -  A Response object, from the Swagger API
+ * @param   {string}    responseId  -  A value that uniquely identifies the response
+ */
+function validateResponse (code, response, responseId) {
+  if (code !== "default" && (code < 100 || code > 599)) {
+    throw ono.syntax(`Validation failed. ${responseId} has an invalid response code (${code})`);
+  }
+
+  let headers = Object.keys(response.headers || {});
+  for (let headerName of headers) {
+    let header = response.headers[headerName];
+    let headerId = responseId + "/headers/" + headerName;
+    validateSchema(header, headerId, primitiveTypes);
+  }
+
+  if (response.schema) {
+    let validTypes = schemaTypes.concat("file");
+    if (validTypes.indexOf(response.schema.type) === -1) {
+      throw ono.syntax(
+        `Validation failed. ${responseId} has an invalid response schema type (${response.schema.type})`);
+    }
+    else {
+      validateSchema(response.schema, responseId + "/schema", validTypes);
+    }
+  }
+}
+
+/**
+ * Validates the given Swagger schema object.
+ *
+ * @param {object}    schema      - A Schema object, from the Swagger API
+ * @param {string}    schemaId    - A value that uniquely identifies the schema object
+ * @param {string[]}  validTypes  - An array of the allowed schema types
+ */
+function validateSchema (schema, schemaId, validTypes) {
+  if (validTypes.indexOf(schema.type) === -1) {
+    throw ono.syntax(
+      `Validation failed. ${schemaId} has an invalid type (${schema.type})`);
+  }
+
+  if (schema.type === "array" && !schema.items) {
+    throw ono.syntax(`Validation failed. ${schemaId} is an array, so it must include an "items" schema`);
+  }
+}
+
+/**
+ * Validates that the declared properties of the given Swagger schema object actually exist.
+ *
+ * @param {object}    schema      - A Schema object, from the Swagger API
+ * @param {string}    schemaId    - A value that uniquely identifies the schema object
+ */
+function validateRequiredPropertiesExist (schema, schemaId) {
+  /**
+   * Recursively collects all properties of the schema and its ancestors. They are added to the props object.
+   */
+  function collectProperties (schemaObj, props) {
+    if (schemaObj.properties) {
+      for (let property in schemaObj.properties) {
+        if (schemaObj.properties.hasOwnProperty(property)) {
+          props[property] = schemaObj.properties[property];
+        }
+      }
+    }
+    if (schemaObj.allOf) {
+      for (let parent of schemaObj.allOf) {
+        collectProperties(parent, props);
+      }
+    }
+  }
+
+  // The "required" keyword is only applicable for objects
+  if (Array.isArray(schema.type) && !schema.type.includes("object")) {
+    return;
+  }
+  else if (!Array.isArray(schema.type) && schema.type !== "object") {
+    return;
+  }
+
+  if (schema.required && Array.isArray(schema.required)) {
+    let props = {};
+    collectProperties(schema, props);
+    for (let requiredProperty of schema.required) {
+      if (!props[requiredProperty]) {
+        throw ono.syntax(
+          `Validation failed. Property '${requiredProperty}' listed as required but does not exist in '${schemaId}'`
+        );
+      }
+    }
+  }
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/README.md

@@ -0,0 +1,40 @@
+# ajv-draft-04
+
+Ajv with JSON Schema draft-04 support
+
+[![build](https://github.com/ajv-validator/ajv-draft-04/actions/workflows/build.yml/badge.svg)](https://github.com/ajv-validator/ajv-draft-04/actions/workflows/build.yml)
+[![npm](https://img.shields.io/npm/v/ajv-draft-04.svg)](https://www.npmjs.com/package/ajv-draft-04)
+[![coverage](https://coveralls.io/repos/github/ajv-validator/ajv-draft-04/badge.svg?branch=master)](https://coveralls.io/github/ajv-validator/ajv-draft-04?branch=master)
+[![Gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv)
+[![GitHub Sponsors](https://img.shields.io/badge/$-sponsors-brightgreen)](https://github.com/sponsors/epoberezkin)
+
+## Usage
+
+You need to install both ajv and this package (to allow upgrading ajv without upgrading this package):
+
+```shell
+npm i ajv ajv-draft-04
+```
+
+```javascript
+// ESM/TypeScript import
+import Ajv from "ajv-draft-04"
+// Node.js require:
+const Ajv = require("ajv-draft-04")
+
+const ajv = new Ajv()
+```
+
+See [ajv site](https://ajv.js.org) for documentation.
+
+## Tests
+
+```bash
+npm install
+git submodule update --init
+npm test
+```
+
+## License
+
+[MIT](https://github.com/ajv-validator/ajv-formats/blob/master/LICENSE)

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type { AnySchemaObject, Options } from "ajv/dist/core";
+import AjvCore from "ajv/dist/core";
+declare class Ajv extends AjvCore {
+    constructor(opts?: Options);
+    _addVocabularies(): void;
+    _addDefaultMetaSchema(): void;
+    defaultMeta(): string | AnySchemaObject | undefined;
+}
+export default Ajv;
+export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, SchemaValidateFunction, ErrorObject, ErrorNoParams, } from "ajv/dist/types";
+export { Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions, } from "ajv/dist/core";
+export { SchemaCxt, SchemaObjCxt } from "ajv/dist/core";
+export { KeywordCxt } from "ajv/dist/core";
+export { DefinedError } from "ajv/dist/core";
+export { JSONType } from "ajv/dist/core";
+export { JSONSchemaType } from "ajv/dist/core";
+export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "ajv/dist/core";

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
+const core_1 = require("ajv/dist/core");
+const draft4_1 = require("./vocabulary/draft4");
+const discriminator_1 = require("ajv/dist/vocabularies/discriminator");
+const draft4MetaSchema = require("./refs/json-schema-draft-04.json");
+const META_SUPPORT_DATA = ["/properties"];
+const META_SCHEMA_ID = "http://json-schema.org/draft-04/schema";
+class Ajv extends core_1.default {
+    constructor(opts = {}) {
+        super({
+            ...opts,
+            schemaId: "id",
+        });
+    }
+    _addVocabularies() {
+        super._addVocabularies();
+        draft4_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+            this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        if (!this.opts.meta)
+            return;
+        const metaSchema = this.opts.$data
+            ? this.$dataMetaSchema(draft4MetaSchema, META_SUPPORT_DATA)
+            : draft4MetaSchema;
+        this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+        return (this.opts.defaultMeta =
+            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));
+    }
+}
+module.exports = exports = Ajv;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Ajv;
+var core_2 = require("ajv/dist/core");
+Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return core_2.KeywordCxt; } });
+var core_3 = require("ajv/dist/core");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return core_3._; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return core_3.str; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return core_3.stringify; } });
+Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return core_3.nil; } });
+Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return core_3.Name; } });
+Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return core_3.CodeGen; } });
+//# sourceMappingURL=index.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,wCAAmC;AACnC,gDAAoD;AACpD,uEAA+D;AAC/D,qEAAoE;AAEpE,MAAM,iBAAiB,GAAG,CAAC,aAAa,CAAC,CAAA;AAEzC,MAAM,cAAc,GAAG,wCAAwC,CAAA;AAE/D,MAAM,GAAI,SAAQ,cAAO;IACvB,YAAY,OAAgB,EAAE;QAC5B,KAAK,CAAC;YACJ,GAAG,IAAI;YACP,QAAQ,EAAE,IAAI;SACf,CAAC,CAAA;IACJ,CAAC;IAED,gBAAgB;QACd,KAAK,CAAC,gBAAgB,EAAE,CAAA;QACxB,gBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;QACxD,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,UAAU,CAAC,uBAAa,CAAC,CAAA;IAC7D,CAAC;IAED,qBAAqB;QACnB,KAAK,CAAC,qBAAqB,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAM;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK;YAChC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,gBAAgB,EAAE,iBAAiB,CAAC;YAC3D,CAAC,CAAC,gBAAgB,CAAA;QACpB,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,cAAc,EAAE,KAAK,CAAC,CAAA;QACrD,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,GAAG,cAAc,CAAA;IAC7D,CAAC;IAED,WAAW;QACT,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;YAC3B,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;IACzF,CAAC;CACF;AAED,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,GAAG,CAAA;AAC9B,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;AAE3D,kBAAe,GAAG,CAAA;AAiClB,sCAAwC;AAAhC,kGAAA,UAAU,OAAA;AAIlB,sCAAyF;AAAjF,yFAAA,CAAC,OAAA;AAAE,2FAAA,GAAG,OAAA;AAAE,iGAAA,SAAS,OAAA;AAAE,2FAAA,GAAG,OAAA;AAAE,4FAAA,IAAI,OAAA;AAAQ,+FAAA,OAAO,OAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/refs/json-schema-draft-04.json

@@ -0,0 +1,138 @@
+{
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$ref": "#"}
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{"$ref": "#/definitions/positiveInteger"}, {"default": 0}]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": {"$ref": "#/definitions/positiveInteger"},
+    "minLength": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/schemaArray"}],
+      "default": {}
+    },
+    "maxItems": {"$ref": "#/definitions/positiveInteger"},
+    "minItems": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": {"$ref": "#/definitions/positiveInteger"},
+    "minProperties": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "required": {"$ref": "#/definitions/stringArray"},
+    "additionalProperties": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/stringArray"}]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        {"$ref": "#/definitions/simpleTypes"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/simpleTypes"},
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "allOf": {"$ref": "#/definitions/schemaArray"},
+    "anyOf": {"$ref": "#/definitions/schemaArray"},
+    "oneOf": {"$ref": "#/definitions/schemaArray"},
+    "not": {"$ref": "#"}
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/core.d.ts

@@ -0,0 +1,3 @@
+import type { Vocabulary } from "ajv/dist/core";
+declare const core: Vocabulary;
+export default core;

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/core.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ref_1 = require("ajv/dist/vocabularies/core/ref");
+const core = [
+    "$schema",
+    "id",
+    "$defs",
+    { keyword: "$comment" },
+    "definitions",
+    ref_1.default,
+];
+exports.default = core;
+//# sourceMappingURL=core.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/vocabulary/core.ts"],"names":[],"mappings":";;AACA,wDAAuD;AAEvD,MAAM,IAAI,GAAe;IACvB,SAAS;IACT,IAAI;IACJ,OAAO;IACP,EAAC,OAAO,EAAE,UAAU,EAAC;IACrB,aAAa;IACb,aAAU;CACX,CAAA;AAED,kBAAe,IAAI,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/draft4.d.ts

@@ -0,0 +1,3 @@
+import type { Vocabulary } from "ajv/dist/core";
+declare const draft4Vocabularies: Vocabulary[];
+export default draft4Vocabularies;

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/draft4.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("./core");
+const validation_1 = require("./validation");
+const applicator_1 = require("ajv/dist/vocabularies/applicator");
+const format_1 = require("ajv/dist/vocabularies/format");
+const metadataVocabulary = ["title", "description", "default"];
+const draft4Vocabularies = [
+    core_1.default,
+    validation_1.default,
+    applicator_1.default(),
+    format_1.default,
+    metadataVocabulary,
+];
+exports.default = draft4Vocabularies;
+//# sourceMappingURL=draft4.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/draft4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft4.js","sourceRoot":"","sources":["../../src/vocabulary/draft4.ts"],"names":[],"mappings":";;AACA,iCAAmC;AACnC,6CAA2C;AAC3C,iEAAsE;AACtE,yDAA2D;AAE3D,MAAM,kBAAkB,GAAe,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,CAAA;AAE1E,MAAM,kBAAkB,GAAiB;IACvC,cAAc;IACd,oBAAgB;IAChB,oBAAuB,EAAE;IACzB,gBAAgB;IAChB,kBAAkB;CACnB,CAAA;AAED,kBAAe,kBAAkB,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/index.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorObject, Vocabulary } from "ajv/dist/core";
+import { LimitNumberError } from "./limitNumber";
+import { MultipleOfError } from "ajv/dist/vocabularies/validation/multipleOf";
+import { PatternError } from "ajv/dist/vocabularies/validation/pattern";
+import { RequiredError } from "ajv/dist/vocabularies/validation/required";
+import { UniqueItemsError } from "ajv/dist/vocabularies/validation/uniqueItems";
+import { ConstError } from "ajv/dist/vocabularies/validation/const";
+import { EnumError } from "ajv/dist/vocabularies/validation/enum";
+declare const validation: Vocabulary;
+export default validation;
+declare type LimitError = ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", {
+    limit: number;
+}, number | {
+    $data: string;
+}>;
+export declare type ValidationKeywordError = LimitError | LimitNumberError | MultipleOfError | PatternError | RequiredError | UniqueItemsError | ConstError | EnumError;

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const limitNumber_1 = require("./limitNumber");
+const limitNumberExclusive_1 = require("./limitNumberExclusive");
+const multipleOf_1 = require("ajv/dist/vocabularies/validation/multipleOf");
+const limitLength_1 = require("ajv/dist/vocabularies/validation/limitLength");
+const pattern_1 = require("ajv/dist/vocabularies/validation/pattern");
+const limitProperties_1 = require("ajv/dist/vocabularies/validation/limitProperties");
+const required_1 = require("ajv/dist/vocabularies/validation/required");
+const limitItems_1 = require("ajv/dist/vocabularies/validation/limitItems");
+const uniqueItems_1 = require("ajv/dist/vocabularies/validation/uniqueItems");
+const const_1 = require("ajv/dist/vocabularies/validation/const");
+const enum_1 = require("ajv/dist/vocabularies/validation/enum");
+const validation = [
+    // number
+    limitNumber_1.default,
+    limitNumberExclusive_1.default,
+    multipleOf_1.default,
+    // string
+    limitLength_1.default,
+    pattern_1.default,
+    // object
+    limitProperties_1.default,
+    required_1.default,
+    // array
+    limitItems_1.default,
+    uniqueItems_1.default,
+    // any
+    { keyword: "type", schemaType: ["string", "array"] },
+    { keyword: "nullable", schemaType: "boolean" },
+    const_1.default,
+    enum_1.default,
+];
+exports.default = validation;
+//# sourceMappingURL=index.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/vocabulary/validation/index.ts"],"names":[],"mappings":";;AACA,+CAA2D;AAC3D,iEAAyD;AACzD,4EAAuF;AACvF,8EAAsE;AACtE,sEAA8E;AAC9E,sFAA8E;AAC9E,wEAAiF;AACjF,4EAAoE;AACpE,8EAA0F;AAC1F,kEAA+E;AAC/E,gEAA4E;AAE5E,MAAM,UAAU,GAAe;IAC7B,SAAS;IACT,qBAAW;IACX,8BAAoB;IACpB,oBAAU;IACV,SAAS;IACT,qBAAW;IACX,iBAAO;IACP,SAAS;IACT,yBAAe;IACf,kBAAQ;IACR,QAAQ;IACR,oBAAU;IACV,qBAAW;IACX,MAAM;IACN,EAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAC;IAClD,EAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAC;IAC5C,eAAY;IACZ,cAAW;CACZ,CAAA;AAED,kBAAe,UAAU,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumber.d.ts

@@ -0,0 +1,12 @@
+import type { CodeKeywordDefinition, ErrorObject } from "ajv/dist/core";
+export declare type LimitKwd = "maximum" | "minimum";
+export declare type ExclusiveLimitKwd = "exclusiveMaximum" | "exclusiveMinimum";
+declare type Comparison = "<=" | ">=" | "<" | ">";
+export declare type LimitNumberError = ErrorObject<LimitKwd, {
+    limit: number;
+    comparison: Comparison;
+}, number | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumber.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("ajv/dist/core");
+const codegen_1 = require("ajv/dist/compile/codegen");
+const ops = codegen_1.operators;
+const KWDs = {
+    maximum: {
+        exclusive: "exclusiveMaximum",
+        ops: [
+            { okStr: "<=", ok: ops.LTE, fail: ops.GT },
+            { okStr: "<", ok: ops.LT, fail: ops.GTE },
+        ],
+    },
+    minimum: {
+        exclusive: "exclusiveMinimum",
+        ops: [
+            { okStr: ">=", ok: ops.GTE, fail: ops.LT },
+            { okStr: ">", ok: ops.GT, fail: ops.LTE },
+        ],
+    },
+};
+const error = {
+    message: (cxt) => core_1.str `must be ${kwdOp(cxt).okStr} ${cxt.schemaCode}`,
+    params: (cxt) => core_1._ `{comparison: ${kwdOp(cxt).okStr}, limit: ${cxt.schemaCode}}`,
+};
+const def = {
+    keyword: Object.keys(KWDs),
+    type: "number",
+    schemaType: "number",
+    $data: true,
+    error,
+    code(cxt) {
+        const { data, schemaCode } = cxt;
+        cxt.fail$data(core_1._ `${data} ${kwdOp(cxt).fail} ${schemaCode} || isNaN(${data})`);
+    },
+};
+function kwdOp(cxt) {
+    var _a;
+    const keyword = cxt.keyword;
+    const opsIdx = ((_a = cxt.parentSchema) === null || _a === void 0 ? void 0 : _a[KWDs[keyword].exclusive]) ? 1 : 0;
+    return KWDs[keyword].ops[opsIdx];
+}
+exports.default = def;
+//# sourceMappingURL=limitNumber.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitNumber.js","sourceRoot":"","sources":["../../../src/vocabulary/validation/limitNumber.ts"],"names":[],"mappings":";;AAOA,wCAA0C;AAC1C,sDAAkD;AAElD,MAAM,GAAG,GAAG,mBAAS,CAAA;AAmBrB,MAAM,IAAI,GAA8B;IACtC,OAAO,EAAE;QACP,SAAS,EAAE,kBAAkB;QAC7B,GAAG,EAAE;YACH,EAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,EAAC;YACxC,EAAC,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,EAAC;SACxC;KACF;IACD,OAAO,EAAE;QACP,SAAS,EAAE,kBAAkB;QAC7B,GAAG,EAAE;YACH,EAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,EAAC;YACxC,EAAC,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,EAAC;SACxC;KACF;CACF,CAAA;AAQD,MAAM,KAAK,GAA2B;IACpC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,UAAG,CAAA,WAAW,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,UAAU,EAAE;IACpE,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAC,CAAA,gBAAgB,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,UAAU,GAAG;CAChF,CAAA;AAED,MAAM,GAAG,GAA0B;IACjC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IAC1B,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE,QAAQ;IACpB,KAAK,EAAE,IAAI;IACX,KAAK;IACL,IAAI,CAAC,GAAe;QAClB,MAAM,EAAC,IAAI,EAAE,UAAU,EAAC,GAAG,GAAG,CAAA;QAC9B,GAAG,CAAC,SAAS,CAAC,QAAC,CAAA,GAAG,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,UAAU,aAAa,IAAI,GAAG,CAAC,CAAA;IAC9E,CAAC;CACF,CAAA;AAED,SAAS,KAAK,CAAC,GAAoB;;IACjC,MAAM,OAAO,GAAG,GAAG,CAAC,OAAmB,CAAA;IACvC,MAAM,MAAM,GAAG,CAAA,MAAA,GAAG,CAAC,YAAY,0CAAG,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAClE,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AAClC,CAAC;AAED,kBAAe,GAAG,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumberExclusive.d.ts

@@ -0,0 +1,3 @@
+import type { CodeKeywordDefinition } from "ajv/dist/core";
+declare const def: CodeKeywordDefinition;
+export default def;

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumberExclusive.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KWDs = {
+    exclusiveMaximum: "maximum",
+    exclusiveMinimum: "minimum",
+};
+const def = {
+    keyword: Object.keys(KWDs),
+    type: "number",
+    schemaType: "boolean",
+    code({ keyword, parentSchema }) {
+        const limitKwd = KWDs[keyword];
+        if (parentSchema[limitKwd] === undefined) {
+            throw new Error(`${keyword} can only be used with ${limitKwd}`);
+        }
+    },
+};
+exports.default = def;
+//# sourceMappingURL=limitNumberExclusive.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/dist/vocabulary/validation/limitNumberExclusive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitNumberExclusive.js","sourceRoot":"","sources":["../../../src/vocabulary/validation/limitNumberExclusive.ts"],"names":[],"mappings":";;AAQA,MAAM,IAAI,GAAyC;IACjD,gBAAgB,EAAE,SAAS;IAC3B,gBAAgB,EAAE,SAAS;CAC5B,CAAA;AAED,MAAM,GAAG,GAA0B;IACjC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;IAC1B,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE,SAAS;IACrB,IAAI,CAAC,EAAC,OAAO,EAAE,YAAY,EAAa;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAA4B,CAAC,CAAA;QACnD,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,SAAS,EAAE;YACxC,MAAM,IAAI,KAAK,CAAC,GAAG,OAAO,0BAA0B,QAAQ,EAAE,CAAC,CAAA;SAChE;IACH,CAAC;CACF,CAAA;AAED,kBAAe,GAAG,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "ajv-draft-04",
+  "version": "1.0.0",
+  "description": "Ajv class for JSON Schema draft-04",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc && cp -r src/refs dist",
+    "prettier:write": "prettier --write \"./**/*.{json,yaml,js,ts}\"",
+    "prettier:check": "prettier --list-different \"./**/*.{json,yaml,js,ts}\"",
+    "eslint": "eslint \"./{src,tests,scripts}/**/*.{ts,js}\"",
+    "json-tests": "rm -rf tests/_json/*.js && node scripts/jsontests",
+    "test-spec": "jest",
+    "test-cov": "jest --coverage",
+    "test-debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
+    "test": "npm run json-tests && npm run prettier:check && npm run build && npm run eslint && npm run test-cov",
+    "test-ci": "AJV_FULL_TEST=true npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ajv-validator/ajv-draft-04.git"
+  },
+  "keywords": [
+    "Ajv",
+    "JSON-Schema",
+    "validation",
+    "draft-04"
+  ],
+  "author": "Evgeny Poberezkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ajv-validator/ajv-draft-04/issues"
+  },
+  "homepage": "https://github.com/ajv-validator/ajv-draft-04#readme",
+  "dependencies": {},
+  "peerDependencies": {
+    "ajv": "^8.5.0"
+  },
+  "peerDependenciesMeta": {
+    "ajv": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ajv-validator/config": "^0.3.0",
+    "@types/jest": "^26.0.5",
+    "@types/node": "^14.10.1",
+    "@typescript-eslint/eslint-plugin": "^3.7.0",
+    "@typescript-eslint/parser": "^3.7.0",
+    "ajv-formats": "^2.0.0",
+    "eslint": "^7.5.0",
+    "eslint-config-prettier": "^6.11.0",
+    "husky": "^4.2.5",
+    "jest": "^26.1.0",
+    "json-schema-test": "^2.0.0",
+    "lint-staged": "^10.2.11",
+    "prettier": "^2.0.5",
+    "ts-jest": "^26.1.3",
+    "typescript": "^4.0.0"
+  },
+  "prettier": "@ajv-validator/config/prettierrc.json",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged && npm test"
+    }
+  },
+  "lint-staged": {
+    "*.{json,yaml,js,ts}": "prettier --write"
+  }
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/index.ts

@@ -0,0 +1,81 @@
+import type {AnySchemaObject, Options} from "ajv/dist/core"
+import AjvCore from "ajv/dist/core"
+import draft4Vocabularies from "./vocabulary/draft4"
+import discriminator from "ajv/dist/vocabularies/discriminator"
+import * as draft4MetaSchema from "./refs/json-schema-draft-04.json"
+
+const META_SUPPORT_DATA = ["/properties"]
+
+const META_SCHEMA_ID = "http://json-schema.org/draft-04/schema"
+
+class Ajv extends AjvCore {
+  constructor(opts: Options = {}) {
+    super({
+      ...opts,
+      schemaId: "id",
+    })
+  }
+
+  _addVocabularies(): void {
+    super._addVocabularies()
+    draft4Vocabularies.forEach((v) => this.addVocabulary(v))
+    if (this.opts.discriminator) this.addKeyword(discriminator)
+  }
+
+  _addDefaultMetaSchema(): void {
+    super._addDefaultMetaSchema()
+    if (!this.opts.meta) return
+    const metaSchema = this.opts.$data
+      ? this.$dataMetaSchema(draft4MetaSchema, META_SUPPORT_DATA)
+      : draft4MetaSchema
+    this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)
+    this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID
+  }
+
+  defaultMeta(): string | AnySchemaObject | undefined {
+    return (this.opts.defaultMeta =
+      super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))
+  }
+}
+
+module.exports = exports = Ajv
+Object.defineProperty(exports, "__esModule", {value: true})
+
+export default Ajv
+
+export {
+  Format,
+  FormatDefinition,
+  AsyncFormatDefinition,
+  KeywordDefinition,
+  KeywordErrorDefinition,
+  CodeKeywordDefinition,
+  MacroKeywordDefinition,
+  FuncKeywordDefinition,
+  Vocabulary,
+  Schema,
+  SchemaObject,
+  AnySchemaObject,
+  AsyncSchema,
+  AnySchema,
+  ValidateFunction,
+  AsyncValidateFunction,
+  SchemaValidateFunction,
+  ErrorObject,
+  ErrorNoParams,
+} from "ajv/dist/types"
+
+export {
+  Plugin,
+  Options,
+  CodeOptions,
+  InstanceOptions,
+  Logger,
+  ErrorsTextOptions,
+} from "ajv/dist/core"
+export {SchemaCxt, SchemaObjCxt} from "ajv/dist/core"
+export {KeywordCxt} from "ajv/dist/core"
+export {DefinedError} from "ajv/dist/core"
+export {JSONType} from "ajv/dist/core"
+export {JSONSchemaType} from "ajv/dist/core"
+export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "ajv/dist/core"

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/refs/json-schema-draft-04.json

@@ -0,0 +1,138 @@
+{
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$ref": "#"}
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{"$ref": "#/definitions/positiveInteger"}, {"default": 0}]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": {"$ref": "#/definitions/positiveInteger"},
+    "minLength": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/schemaArray"}],
+      "default": {}
+    },
+    "maxItems": {"$ref": "#/definitions/positiveInteger"},
+    "minItems": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": {"$ref": "#/definitions/positiveInteger"},
+    "minProperties": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "required": {"$ref": "#/definitions/stringArray"},
+    "additionalProperties": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/stringArray"}]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        {"$ref": "#/definitions/simpleTypes"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/simpleTypes"},
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "allOf": {"$ref": "#/definitions/schemaArray"},
+    "anyOf": {"$ref": "#/definitions/schemaArray"},
+    "oneOf": {"$ref": "#/definitions/schemaArray"},
+    "not": {"$ref": "#"}
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/vocabulary/core.ts

@@ -0,0 +1,13 @@
+import type {Vocabulary} from "ajv/dist/core"
+import refKeyword from "ajv/dist/vocabularies/core/ref"
+
+const core: Vocabulary = [
+  "$schema",
+  "id",
+  "$defs",
+  {keyword: "$comment"},
+  "definitions",
+  refKeyword,
+]
+
+export default core

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/vocabulary/draft4.ts

@@ -0,0 +1,17 @@
+import type {Vocabulary} from "ajv/dist/core"
+import coreVocabulary from "./core"
+import validationDraft4 from "./validation"
+import getApplicatorVocabulary from "ajv/dist/vocabularies/applicator"
+import formatVocabulary from "ajv/dist/vocabularies/format"
+
+const metadataVocabulary: Vocabulary = ["title", "description", "default"]
+
+const draft4Vocabularies: Vocabulary[] = [
+  coreVocabulary,
+  validationDraft4,
+  getApplicatorVocabulary(),
+  formatVocabulary,
+  metadataVocabulary,
+]
+
+export default draft4Vocabularies

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/vocabulary/validation/index.ts

@@ -0,0 +1,51 @@
+import type {ErrorObject, Vocabulary} from "ajv/dist/core"
+import limitNumber, {LimitNumberError} from "./limitNumber"
+import limitNumberExclusive from "./limitNumberExclusive"
+import multipleOf, {MultipleOfError} from "ajv/dist/vocabularies/validation/multipleOf"
+import limitLength from "ajv/dist/vocabularies/validation/limitLength"
+import pattern, {PatternError} from "ajv/dist/vocabularies/validation/pattern"
+import limitProperties from "ajv/dist/vocabularies/validation/limitProperties"
+import required, {RequiredError} from "ajv/dist/vocabularies/validation/required"
+import limitItems from "ajv/dist/vocabularies/validation/limitItems"
+import uniqueItems, {UniqueItemsError} from "ajv/dist/vocabularies/validation/uniqueItems"
+import constKeyword, {ConstError} from "ajv/dist/vocabularies/validation/const"
+import enumKeyword, {EnumError} from "ajv/dist/vocabularies/validation/enum"
+
+const validation: Vocabulary = [
+  // number
+  limitNumber,
+  limitNumberExclusive,
+  multipleOf,
+  // string
+  limitLength,
+  pattern,
+  // object
+  limitProperties,
+  required,
+  // array
+  limitItems,
+  uniqueItems,
+  // any
+  {keyword: "type", schemaType: ["string", "array"]},
+  {keyword: "nullable", schemaType: "boolean"},
+  constKeyword,
+  enumKeyword,
+]
+
+export default validation
+
+type LimitError = ErrorObject<
+  "maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength",
+  {limit: number},
+  number | {$data: string}
+>
+
+export type ValidationKeywordError =
+  | LimitError
+  | LimitNumberError
+  | MultipleOfError
+  | PatternError
+  | RequiredError
+  | UniqueItemsError
+  | ConstError
+  | EnumError

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/vocabulary/validation/limitNumber.ts

@@ -0,0 +1,76 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordCxt,
+  KeywordErrorDefinition,
+} from "ajv/dist/core"
+import type {KeywordErrorCxt} from "ajv/dist/types"
+import {_, str, Code} from "ajv/dist/core"
+import {operators} from "ajv/dist/compile/codegen"
+
+const ops = operators
+
+export type LimitKwd = "maximum" | "minimum"
+
+export type ExclusiveLimitKwd = "exclusiveMaximum" | "exclusiveMinimum"
+
+type Comparison = "<=" | ">=" | "<" | ">"
+
+interface KwdOp {
+  okStr: Comparison
+  ok: Code
+  fail: Code
+}
+
+interface KwdDef {
+  exclusive: ExclusiveLimitKwd
+  ops: [KwdOp, KwdOp]
+}
+
+const KWDs: {[K in LimitKwd]: KwdDef} = {
+  maximum: {
+    exclusive: "exclusiveMaximum",
+    ops: [
+      {okStr: "<=", ok: ops.LTE, fail: ops.GT},
+      {okStr: "<", ok: ops.LT, fail: ops.GTE},
+    ],
+  },
+  minimum: {
+    exclusive: "exclusiveMinimum",
+    ops: [
+      {okStr: ">=", ok: ops.GTE, fail: ops.LT},
+      {okStr: ">", ok: ops.GT, fail: ops.LTE},
+    ],
+  },
+}
+
+export type LimitNumberError = ErrorObject<
+  LimitKwd,
+  {limit: number; comparison: Comparison},
+  number | {$data: string}
+>
+
+const error: KeywordErrorDefinition = {
+  message: (cxt) => str`must be ${kwdOp(cxt).okStr} ${cxt.schemaCode}`,
+  params: (cxt) => _`{comparison: ${kwdOp(cxt).okStr}, limit: ${cxt.schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "number",
+  $data: true,
+  error,
+  code(cxt: KeywordCxt) {
+    const {data, schemaCode} = cxt
+    cxt.fail$data(_`${data} ${kwdOp(cxt).fail} ${schemaCode} || isNaN(${data})`)
+  },
+}
+
+function kwdOp(cxt: KeywordErrorCxt): KwdOp {
+  const keyword = cxt.keyword as LimitKwd
+  const opsIdx = cxt.parentSchema?.[KWDs[keyword].exclusive] ? 1 : 0
+  return KWDs[keyword].ops[opsIdx]
+}
+
+export default def

node_modules/@apidevtools/swagger-parser/node_modules/ajv-draft-04/src/vocabulary/validation/limitNumberExclusive.ts

@@ -0,0 +1,26 @@
+import type {
+  CodeKeywordDefinition,
+  // ErrorObject,
+  KeywordCxt,
+  // KeywordErrorDefinition,
+} from "ajv/dist/core"
+import {LimitKwd, ExclusiveLimitKwd} from "./limitNumber"
+
+const KWDs: {[K in ExclusiveLimitKwd]: LimitKwd} = {
+  exclusiveMaximum: "maximum",
+  exclusiveMinimum: "minimum",
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "boolean",
+  code({keyword, parentSchema}: KeywordCxt) {
+    const limitKwd = KWDs[keyword as ExclusiveLimitKwd]
+    if (parentSchema[limitKwd] === undefined) {
+      throw new Error(`${keyword} can only be used with ${limitKwd}`)
+    }
+  },
+}
+
+export default def

node_modules/@apidevtools/swagger-parser/node_modules/ajv/.runkit_example.js

@@ -0,0 +1,23 @@
+const Ajv = require("ajv")
+const ajv = new Ajv({allErrors: true})
+
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "string"},
+    bar: {type: "number", maximum: 3},
+  },
+  required: ["foo", "bar"],
+  additionalProperties: false,
+}
+
+const validate = ajv.compile(schema)
+
+test({foo: "abc", bar: 2})
+test({foo: 2, bar: 4})
+
+function test(data) {
+  const valid = validate(data)
+  if (valid) console.log("Valid!")
+  else console.log("Invalid: " + ajv.errorsText(validate.errors))
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2021 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

node_modules/@apidevtools/swagger-parser/node_modules/ajv/README.md

@@ -0,0 +1,207 @@
+<img align="right" alt="Ajv logo" width="160" src="https://ajv.js.org/img/ajv.svg">
+
+&nbsp;
+
+# Ajv JSON schema validator
+
+The fastest JSON validator for Node.js and browser.
+
+Supports JSON Schema draft-04/06/07/2019-09/2020-12 ([draft-04 support](https://ajv.js.org/json-schema.html#draft-04) requires ajv-draft-04 package) and JSON Type Definition [RFC8927](https://datatracker.ietf.org/doc/rfc8927/).
+
+[![build](https://github.com/ajv-validator/ajv/actions/workflows/build.yml/badge.svg)](https://github.com/ajv-validator/ajv/actions?query=workflow%3Abuild)
+[![npm](https://img.shields.io/npm/v/ajv.svg)](https://www.npmjs.com/package/ajv)
+[![npm downloads](https://img.shields.io/npm/dm/ajv.svg)](https://www.npmjs.com/package/ajv)
+[![Coverage Status](https://coveralls.io/repos/github/ajv-validator/ajv/badge.svg?branch=master)](https://coveralls.io/github/ajv-validator/ajv?branch=master)
+[![SimpleX](https://img.shields.io/badge/chat-on%20SimpleX-70F0F9)](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F8KvvURM6J38Gdq9dCuPswMOkMny0xCOJ%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAr8rPVRuMOXv6kwF2yUAap-eoVg-9ssOFCi1fIrxTUw0%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%224pwLRgWHU9tlroMWHz0uOg%3D%3D%22%7D)
+[![Gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv)
+[![GitHub Sponsors](https://img.shields.io/badge/$-sponsors-brightgreen)](https://github.com/sponsors/epoberezkin)
+
+## Ajv sponsors
+
+[<img src="https://ajv.js.org/img/mozilla.svg" width="45%" alt="Mozilla">](https://www.mozilla.org)<img src="https://ajv.js.org/img/gap.svg" width="9%">[<img src="https://ajv.js.org/img/reserved.svg" width="45%">](https://opencollective.com/ajv)
+
+[<img src="https://ajv.js.org/img/microsoft.png" width="31%" alt="Microsoft">](https://opensource.microsoft.com)<img src="https://ajv.js.org/img/gap.svg" width="3%">[<img src="https://ajv.js.org/img/reserved.svg" width="31%">](https://opencollective.com/ajv)<img src="https://ajv.js.org/img/gap.svg" width="3%">[<img src="https://ajv.js.org/img/reserved.svg" width="31%">](https://opencollective.com/ajv)
+
+[<img src="https://ajv.js.org/img/retool.svg" width="22.5%" alt="Retool">](https://retool.com/?utm_source=sponsor&utm_campaign=ajv)<img src="https://ajv.js.org/img/gap.svg" width="3%">[<img src="https://ajv.js.org/img/tidelift.svg" width="22.5%" alt="Tidelift">](https://tidelift.com/subscription/pkg/npm-ajv?utm_source=npm-ajv&utm_medium=referral&utm_campaign=enterprise)<img src="https://ajv.js.org/img/gap.svg" width="3%">[<img src="https://ajv.js.org/img/simplex.svg" width="22.5%" alt="SimpleX">](https://github.com/simplex-chat/simplex-chat)<img src="https://ajv.js.org/img/gap.svg" width="3%">[<img src="https://ajv.js.org/img/reserved.svg" width="22.5%">](https://opencollective.com/ajv)
+
+## Contributing
+
+More than 100 people contributed to Ajv, and we would love to have you join the development. We welcome implementing new features that will benefit many users and ideas to improve our documentation.
+
+Please review [Contributing guidelines](./CONTRIBUTING.md) and [Code components](https://ajv.js.org/components.html).
+
+## Documentation
+
+All documentation is available on the [Ajv website](https://ajv.js.org).
+
+Some useful site links:
+
+- [Getting started](https://ajv.js.org/guide/getting-started.html)
+- [JSON Schema vs JSON Type Definition](https://ajv.js.org/guide/schema-language.html)
+- [API reference](https://ajv.js.org/api.html)
+- [Strict mode](https://ajv.js.org/strict-mode.html)
+- [Standalone validation code](https://ajv.js.org/standalone.html)
+- [Security considerations](https://ajv.js.org/security.html)
+- [Command line interface](https://ajv.js.org/packages/ajv-cli.html)
+- [Frequently Asked Questions](https://ajv.js.org/faq.html)
+
+## <a name="sponsors"></a>Please [sponsor Ajv development](https://github.com/sponsors/epoberezkin)
+
+Since I asked to support Ajv development 40 people and 6 organizations contributed via GitHub and OpenCollective - this support helped receiving the MOSS grant!
+
+Your continuing support is very important - the funds will be used to develop and maintain Ajv once the next major version is released.
+
+Please sponsor Ajv via:
+
+- [GitHub sponsors page](https://github.com/sponsors/epoberezkin) (GitHub will match it)
+- [Ajv Open Collective](https://opencollective.com/ajv)
+
+Thank you.
+
+#### Open Collective sponsors
+
+<a href="https://opencollective.com/ajv"><img src="https://opencollective.com/ajv/individuals.svg?width=890"></a>
+
+<a href="https://opencollective.com/ajv/organization/0/website"><img src="https://opencollective.com/ajv/organization/0/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/1/website"><img src="https://opencollective.com/ajv/organization/1/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/2/website"><img src="https://opencollective.com/ajv/organization/2/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/3/website"><img src="https://opencollective.com/ajv/organization/3/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/4/website"><img src="https://opencollective.com/ajv/organization/4/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/5/website"><img src="https://opencollective.com/ajv/organization/5/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/6/website"><img src="https://opencollective.com/ajv/organization/6/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/7/website"><img src="https://opencollective.com/ajv/organization/7/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/8/website"><img src="https://opencollective.com/ajv/organization/8/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/9/website"><img src="https://opencollective.com/ajv/organization/9/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/10/website"><img src="https://opencollective.com/ajv/organization/10/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/11/website"><img src="https://opencollective.com/ajv/organization/11/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/12/website"><img src="https://opencollective.com/ajv/organization/12/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/13/website"><img src="https://opencollective.com/ajv/organization/13/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/14/website"><img src="https://opencollective.com/ajv/organization/14/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/15/website"><img src="https://opencollective.com/ajv/organization/15/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/16/website"><img src="https://opencollective.com/ajv/organization/16/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/17/website"><img src="https://opencollective.com/ajv/organization/17/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/18/website"><img src="https://opencollective.com/ajv/organization/18/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/19/website"><img src="https://opencollective.com/ajv/organization/19/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/20/website"><img src="https://opencollective.com/ajv/organization/20/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/21/website"><img src="https://opencollective.com/ajv/organization/21/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/22/website"><img src="https://opencollective.com/ajv/organization/22/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/23/website"><img src="https://opencollective.com/ajv/organization/23/avatar.svg"></a>
+<a href="https://opencollective.com/ajv/organization/24/website"><img src="https://opencollective.com/ajv/organization/24/avatar.svg"></a>
+
+## Performance
+
+Ajv generates code to turn JSON Schemas into super-fast validation functions that are efficient for v8 optimization.
+
+Currently Ajv is the fastest and the most standard compliant validator according to these benchmarks:
+
+- [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark) - 50% faster than the second place
+- [jsck benchmark](https://github.com/pandastrike/jsck#benchmarks) - 20-190% faster
+- [z-schema benchmark](https://rawgit.com/zaggino/z-schema/master/benchmark/results.html)
+- [themis benchmark](https://cdn.rawgit.com/playlyfe/themis/master/benchmark/results.html)
+
+Performance of different validators by [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark):
+
+[![performance](https://chart.googleapis.com/chart?chxt=x,y&cht=bhs&chco=76A4FB&chls=2.0&chbh=62,4,1&chs=600x416&chxl=-1:|ajv|@exodus/schemasafe|is-my-json-valid|djv|@cfworker/json-schema|jsonschema/=t:100,69.2,51.5,13.1,5.1,1.2)](https://github.com/ebdrup/json-schema-benchmark/blob/master/README.md#performance)
+
+## Features
+
+- Ajv implements JSON Schema [draft-06/07/2019-09/2020-12](http://json-schema.org/) standards (draft-04 is supported in v6):
+  - all validation keywords (see [JSON Schema validation keywords](https://ajv.js.org/json-schema.html))
+  - [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md) extensions:
+    - NEW: keyword [discriminator](https://ajv.js.org/json-schema.html#discriminator).
+    - keyword [nullable](https://ajv.js.org/json-schema.html#nullable).
+  - full support of remote references (remote schemas have to be added with `addSchema` or compiled to be available)
+  - support of recursive references between schemas
+  - correct string lengths for strings with unicode pairs
+  - JSON Schema [formats](https://ajv.js.org/guide/formats.html) (with [ajv-formats](https://github.com/ajv-validator/ajv-formats) plugin).
+  - [validates schemas against meta-schema](https://ajv.js.org/api.html#api-validateschema)
+- NEW: supports [JSON Type Definition](https://datatracker.ietf.org/doc/rfc8927/):
+  - all keywords (see [JSON Type Definition schema forms](https://ajv.js.org/json-type-definition.html))
+  - meta-schema for JTD schemas
+  - "union" keyword and user-defined keywords (can be used inside "metadata" member of the schema)
+- supports [browsers](https://ajv.js.org/guide/environments.html#browsers) and Node.js 10.x - current
+- [asynchronous loading](https://ajv.js.org/guide/managing-schemas.html#asynchronous-schema-loading) of referenced schemas during compilation
+- "All errors" validation mode with [option allErrors](https://ajv.js.org/options.html#allerrors)
+- [error messages with parameters](https://ajv.js.org/api.html#validation-errors) describing error reasons to allow error message generation
+- i18n error messages support with [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) package
+- [removing-additional-properties](https://ajv.js.org/guide/modifying-data.html#removing-additional-properties)
+- [assigning defaults](https://ajv.js.org/guide/modifying-data.html#assigning-defaults) to missing properties and items
+- [coercing data](https://ajv.js.org/guide/modifying-data.html#coercing-data-types) to the types specified in `type` keywords
+- [user-defined keywords](https://ajv.js.org/guide/user-keywords.html)
+- additional extension keywords with [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package
+- [\$data reference](https://ajv.js.org/guide/combining-schemas.html#data-reference) to use values from the validated data as values for the schema keywords
+- [asynchronous validation](https://ajv.js.org/guide/async-validation.html) of user-defined formats and keywords
+
+## Install
+
+To install version 8:
+
+```
+npm install ajv
+```
+
+## <a name="usage"></a>Getting started
+
+Try it in the Node.js REPL: https://runkit.com/npm/ajv
+
+In JavaScript:
+
+```javascript
+// or ESM/TypeScript import
+import Ajv from "ajv"
+// Node.js require:
+const Ajv = require("ajv")
+
+const ajv = new Ajv() // options can be passed, e.g. {allErrors: true}
+
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "integer"},
+    bar: {type: "string"},
+  },
+  required: ["foo"],
+  additionalProperties: false,
+}
+
+const data = {
+  foo: 1,
+  bar: "abc",
+}
+
+const validate = ajv.compile(schema)
+const valid = validate(data)
+if (!valid) console.log(validate.errors)
+```
+
+Learn how to use Ajv and see more examples in the [Guide: getting started](https://ajv.js.org/guide/getting-started.html)
+
+## Changes history
+
+See [https://github.com/ajv-validator/ajv/releases](https://github.com/ajv-validator/ajv/releases)
+
+**Please note**: [Changes in version 8.0.0](https://github.com/ajv-validator/ajv/releases/tag/v8.0.0)
+
+[Version 7.0.0](https://github.com/ajv-validator/ajv/releases/tag/v7.0.0)
+
+[Version 6.0.0](https://github.com/ajv-validator/ajv/releases/tag/v6.0.0).
+
+## Code of conduct
+
+Please review and follow the [Code of conduct](./CODE_OF_CONDUCT.md).
+
+Please report any unacceptable behaviour to ajv.validator@gmail.com - it will be reviewed by the project team.
+
+## Security contact
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues.
+
+## Open-source software support
+
+Ajv is a part of [Tidelift subscription](https://tidelift.com/subscription/pkg/npm-ajv?utm_source=npm-ajv&utm_medium=referral&utm_campaign=readme) - it provides a centralised support to open-source software users, in addition to the support provided by software maintainers.
+
+## License
+
+[MIT](./LICENSE)

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2019.d.ts

@@ -0,0 +1,19 @@
+import type { AnySchemaObject } from "./types";
+import AjvCore, { Options } from "./core";
+export declare class Ajv2019 extends AjvCore {
+    constructor(opts?: Options);
+    _addVocabularies(): void;
+    _addDefaultMetaSchema(): void;
+    defaultMeta(): string | AnySchemaObject | undefined;
+}
+export default Ajv2019;
+export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
+export { Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions } from "./core";
+export { SchemaCxt, SchemaObjCxt } from "./compile";
+export { KeywordCxt } from "./compile/validate";
+export { DefinedError } from "./vocabularies/errors";
+export { JSONType } from "./compile/rules";
+export { JSONSchemaType } from "./types/json-schema";
+export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
+export { default as ValidationError } from "./runtime/validation_error";
+export { default as MissingRefError } from "./compile/ref_error";

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2019.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2019 = void 0;
+const core_1 = require("./core");
+const draft7_1 = require("./vocabularies/draft7");
+const dynamic_1 = require("./vocabularies/dynamic");
+const next_1 = require("./vocabularies/next");
+const unevaluated_1 = require("./vocabularies/unevaluated");
+const discriminator_1 = require("./vocabularies/discriminator");
+const json_schema_2019_09_1 = require("./refs/json-schema-2019-09");
+const META_SCHEMA_ID = "https://json-schema.org/draft/2019-09/schema";
+class Ajv2019 extends core_1.default {
+    constructor(opts = {}) {
+        super({
+            ...opts,
+            dynamicRef: true,
+            next: true,
+            unevaluated: true,
+        });
+    }
+    _addVocabularies() {
+        super._addVocabularies();
+        this.addVocabulary(dynamic_1.default);
+        draft7_1.default.forEach((v) => this.addVocabulary(v));
+        this.addVocabulary(next_1.default);
+        this.addVocabulary(unevaluated_1.default);
+        if (this.opts.discriminator)
+            this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+            return;
+        json_schema_2019_09_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+        return (this.opts.defaultMeta =
+            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));
+    }
+}
+exports.Ajv2019 = Ajv2019;
+module.exports = exports = Ajv2019;
+module.exports.Ajv2019 = Ajv2019;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Ajv2019;
+var validate_1 = require("./compile/validate");
+Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
+var codegen_1 = require("./compile/codegen");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
+Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } });
+Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } });
+Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } });
+var validation_error_1 = require("./runtime/validation_error");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validation_error_1.default; } });
+var ref_error_1 = require("./compile/ref_error");
+Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function () { return ref_error_1.default; } });
+//# sourceMappingURL=2019.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2019.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"2019.js","sourceRoot":"","sources":["../lib/2019.ts"],"names":[],"mappings":";;;AACA,iCAAuC;AAEvC,kDAAsD;AACtD,oDAAsD;AACtD,8CAAgD;AAChD,4DAA8D;AAC9D,gEAAwD;AACxD,oEAA0D;AAE1D,MAAM,cAAc,GAAG,8CAA8C,CAAA;AAErE,MAAa,OAAQ,SAAQ,cAAO;IAClC,YAAY,OAAgB,EAAE;QAC5B,KAAK,CAAC;YACJ,GAAG,IAAI;YACP,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,IAAI;YACV,WAAW,EAAE,IAAI;SAClB,CAAC,CAAA;IACJ,CAAC;IAED,gBAAgB;QACd,KAAK,CAAC,gBAAgB,EAAE,CAAA;QACxB,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAA;QACrC,gBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;QACxD,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;QAClC,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAA;QACzC,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,UAAU,CAAC,uBAAa,CAAC,CAAA;IAC7D,CAAC;IAED,qBAAqB;QACnB,KAAK,CAAC,qBAAqB,EAAE,CAAA;QAC7B,MAAM,EAAC,KAAK,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,IAAI,CAAA;QAC/B,IAAI,CAAC,IAAI;YAAE,OAAM;QACjB,6BAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QACnC,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,GAAG,cAAc,CAAA;IAC7D,CAAC;IAED,WAAW;QACT,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;YAC3B,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;IACzF,CAAC;CACF;AA/BD,0BA+BC;AAED,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;AAClC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,OAAO,CAAA;AAChC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;AAE3D,kBAAe,OAAO,CAAA;AAyBtB,+CAA6C;AAArC,sGAAA,UAAU,OAAA;AAIlB,6CAA6F;AAArF,4FAAA,CAAC,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,oGAAA,SAAS,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,+FAAA,IAAI,OAAA;AAAQ,kGAAA,OAAO,OAAA;AACnD,+DAAqE;AAA7D,mHAAA,OAAO,OAAmB;AAClC,iDAA8D;AAAtD,4GAAA,OAAO,OAAmB"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2020.d.ts

@@ -0,0 +1,19 @@
+import type { AnySchemaObject } from "./types";
+import AjvCore, { Options } from "./core";
+export declare class Ajv2020 extends AjvCore {
+    constructor(opts?: Options);
+    _addVocabularies(): void;
+    _addDefaultMetaSchema(): void;
+    defaultMeta(): string | AnySchemaObject | undefined;
+}
+export default Ajv2020;
+export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
+export { Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions } from "./core";
+export { SchemaCxt, SchemaObjCxt } from "./compile";
+export { KeywordCxt } from "./compile/validate";
+export { DefinedError } from "./vocabularies/errors";
+export { JSONType } from "./compile/rules";
+export { JSONSchemaType } from "./types/json-schema";
+export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
+export { default as ValidationError } from "./runtime/validation_error";
+export { default as MissingRefError } from "./compile/ref_error";

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2020.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+const core_1 = require("./core");
+const draft2020_1 = require("./vocabularies/draft2020");
+const discriminator_1 = require("./vocabularies/discriminator");
+const json_schema_2020_12_1 = require("./refs/json-schema-2020-12");
+const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+class Ajv2020 extends core_1.default {
+    constructor(opts = {}) {
+        super({
+            ...opts,
+            dynamicRef: true,
+            next: true,
+            unevaluated: true,
+        });
+    }
+    _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+            this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+            return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+        return (this.opts.defaultMeta =
+            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));
+    }
+}
+exports.Ajv2020 = Ajv2020;
+module.exports = exports = Ajv2020;
+module.exports.Ajv2020 = Ajv2020;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Ajv2020;
+var validate_1 = require("./compile/validate");
+Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
+var codegen_1 = require("./compile/codegen");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
+Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } });
+Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } });
+Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } });
+var validation_error_1 = require("./runtime/validation_error");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validation_error_1.default; } });
+var ref_error_1 = require("./compile/ref_error");
+Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function () { return ref_error_1.default; } });
+//# sourceMappingURL=2020.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/2020.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"2020.js","sourceRoot":"","sources":["../lib/2020.ts"],"names":[],"mappings":";;;AACA,iCAAuC;AAEvC,wDAA4D;AAC5D,gEAAwD;AACxD,oEAA0D;AAE1D,MAAM,cAAc,GAAG,8CAA8C,CAAA;AAErE,MAAa,OAAQ,SAAQ,cAAO;IAClC,YAAY,OAAgB,EAAE;QAC5B,KAAK,CAAC;YACJ,GAAG,IAAI;YACP,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,IAAI;YACV,WAAW,EAAE,IAAI;SAClB,CAAC,CAAA;IACJ,CAAC;IAED,gBAAgB;QACd,KAAK,CAAC,gBAAgB,EAAE,CAAA;QACxB,mBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;QAC3D,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,UAAU,CAAC,uBAAa,CAAC,CAAA;IAC7D,CAAC;IAED,qBAAqB;QACnB,KAAK,CAAC,qBAAqB,EAAE,CAAA;QAC7B,MAAM,EAAC,KAAK,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,IAAI,CAAA;QAC/B,IAAI,CAAC,IAAI;YAAE,OAAM;QACjB,6BAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QACnC,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,GAAG,cAAc,CAAA;IAC7D,CAAC;IAED,WAAW;QACT,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;YAC3B,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;IACzF,CAAC;CACF;AA5BD,0BA4BC;AAED,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;AAClC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,OAAO,CAAA;AAChC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;AAE3D,kBAAe,OAAO,CAAA;AAyBtB,+CAA6C;AAArC,sGAAA,UAAU,OAAA;AAIlB,6CAA6F;AAArF,4FAAA,CAAC,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,oGAAA,SAAS,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,+FAAA,IAAI,OAAA;AAAQ,kGAAA,OAAO,OAAA;AACnD,+DAAqE;AAA7D,mHAAA,OAAO,OAAmB;AAClC,iDAA8D;AAAtD,4GAAA,OAAO,OAAmB"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/ajv.d.ts

@@ -0,0 +1,18 @@
+import type { AnySchemaObject } from "./types";
+import AjvCore from "./core";
+export declare class Ajv extends AjvCore {
+    _addVocabularies(): void;
+    _addDefaultMetaSchema(): void;
+    defaultMeta(): string | AnySchemaObject | undefined;
+}
+export default Ajv;
+export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, SchemaValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
+export { Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions } from "./core";
+export { SchemaCxt, SchemaObjCxt } from "./compile";
+export { KeywordCxt } from "./compile/validate";
+export { DefinedError } from "./vocabularies/errors";
+export { JSONType } from "./compile/rules";
+export { JSONSchemaType } from "./types/json-schema";
+export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
+export { default as ValidationError } from "./runtime/validation_error";
+export { default as MissingRefError } from "./compile/ref_error";

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/ajv.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
+const core_1 = require("./core");
+const draft7_1 = require("./vocabularies/draft7");
+const discriminator_1 = require("./vocabularies/discriminator");
+const draft7MetaSchema = require("./refs/json-schema-draft-07.json");
+const META_SUPPORT_DATA = ["/properties"];
+const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
+class Ajv extends core_1.default {
+    _addVocabularies() {
+        super._addVocabularies();
+        draft7_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+            this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        if (!this.opts.meta)
+            return;
+        const metaSchema = this.opts.$data
+            ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
+            : draft7MetaSchema;
+        this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+        return (this.opts.defaultMeta =
+            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));
+    }
+}
+exports.Ajv = Ajv;
+module.exports = exports = Ajv;
+module.exports.Ajv = Ajv;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Ajv;
+var validate_1 = require("./compile/validate");
+Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
+var codegen_1 = require("./compile/codegen");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return codegen_1._; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return codegen_1.str; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
+Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return codegen_1.nil; } });
+Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return codegen_1.Name; } });
+Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function () { return codegen_1.CodeGen; } });
+var validation_error_1 = require("./runtime/validation_error");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validation_error_1.default; } });
+var ref_error_1 = require("./compile/ref_error");
+Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function () { return ref_error_1.default; } });
+//# sourceMappingURL=ajv.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/ajv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajv.js","sourceRoot":"","sources":["../lib/ajv.ts"],"names":[],"mappings":";;;AACA,iCAA4B;AAC5B,kDAAsD;AACtD,gEAAwD;AACxD,qEAAoE;AAEpE,MAAM,iBAAiB,GAAG,CAAC,aAAa,CAAC,CAAA;AAEzC,MAAM,cAAc,GAAG,wCAAwC,CAAA;AAE/D,MAAa,GAAI,SAAQ,cAAO;IAC9B,gBAAgB;QACd,KAAK,CAAC,gBAAgB,EAAE,CAAA;QACxB,gBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;QACxD,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,UAAU,CAAC,uBAAa,CAAC,CAAA;IAC7D,CAAC;IAED,qBAAqB;QACnB,KAAK,CAAC,qBAAqB,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAM;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK;YAChC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,gBAAgB,EAAE,iBAAiB,CAAC;YAC3D,CAAC,CAAC,gBAAgB,CAAA;QACpB,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,cAAc,EAAE,KAAK,CAAC,CAAA;QACrD,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,GAAG,cAAc,CAAA;IAC7D,CAAC;IAED,WAAW;QACT,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;YAC3B,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;IACzF,CAAC;CACF;AArBD,kBAqBC;AAED,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,GAAG,CAAA;AAC9B,MAAM,CAAC,OAAO,CAAC,GAAG,GAAG,GAAG,CAAA;AACxB,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;AAE3D,kBAAe,GAAG,CAAA;AA0BlB,+CAA6C;AAArC,sGAAA,UAAU,OAAA;AAIlB,6CAA6F;AAArF,4FAAA,CAAC,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,oGAAA,SAAS,OAAA;AAAE,8FAAA,GAAG,OAAA;AAAE,+FAAA,IAAI,OAAA;AAAQ,kGAAA,OAAO,OAAA;AACnD,+DAAqE;AAA7D,mHAAA,OAAO,OAAmB;AAClC,iDAA8D;AAAtD,4GAAA,OAAO,OAAmB"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/code.d.ts

@@ -0,0 +1,40 @@
+export declare abstract class _CodeOrName {
+    abstract readonly str: string;
+    abstract readonly names: UsedNames;
+    abstract toString(): string;
+    abstract emptyStr(): boolean;
+}
+export declare const IDENTIFIER: RegExp;
+export declare class Name extends _CodeOrName {
+    readonly str: string;
+    constructor(s: string);
+    toString(): string;
+    emptyStr(): boolean;
+    get names(): UsedNames;
+}
+export declare class _Code extends _CodeOrName {
+    readonly _items: readonly CodeItem[];
+    private _str?;
+    private _names?;
+    constructor(code: string | readonly CodeItem[]);
+    toString(): string;
+    emptyStr(): boolean;
+    get str(): string;
+    get names(): UsedNames;
+}
+export type CodeItem = Name | string | number | boolean | null;
+export type UsedNames = Record<string, number | undefined>;
+export type Code = _Code | Name;
+export type SafeExpr = Code | number | boolean | null;
+export declare const nil: _Code;
+type CodeArg = SafeExpr | string | undefined;
+export declare function _(strs: TemplateStringsArray, ...args: CodeArg[]): _Code;
+export declare function str(strs: TemplateStringsArray, ...args: (CodeArg | string[])[]): _Code;
+export declare function addCodeArg(code: CodeItem[], arg: CodeArg | string[]): void;
+export declare function strConcat(c1: Code, c2: Code): Code;
+export declare function stringify(x: unknown): Code;
+export declare function safeStringify(x: unknown): string;
+export declare function getProperty(key: Code | string | number): Code;
+export declare function getEsmExportName(key: Code | string | number): Code;
+export declare function regexpCode(rx: RegExp): Code;
+export {};

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/code.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class _CodeOrName {
+}
+exports._CodeOrName = _CodeOrName;
+exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+class Name extends _CodeOrName {
+    constructor(s) {
+        super();
+        if (!exports.IDENTIFIER.test(s))
+            throw new Error("CodeGen: name must be a valid identifier");
+        this.str = s;
+    }
+    toString() {
+        return this.str;
+    }
+    emptyStr() {
+        return false;
+    }
+    get names() {
+        return { [this.str]: 1 };
+    }
+}
+exports.Name = Name;
+class _Code extends _CodeOrName {
+    constructor(code) {
+        super();
+        this._items = typeof code === "string" ? [code] : code;
+    }
+    toString() {
+        return this.str;
+    }
+    emptyStr() {
+        if (this._items.length > 1)
+            return false;
+        const item = this._items[0];
+        return item === "" || item === '""';
+    }
+    get str() {
+        var _a;
+        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, "")));
+    }
+    get names() {
+        var _a;
+        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {
+            if (c instanceof Name)
+                names[c.str] = (names[c.str] || 0) + 1;
+            return names;
+        }, {})));
+    }
+}
+exports._Code = _Code;
+exports.nil = new _Code("");
+function _(strs, ...args) {
+    const code = [strs[0]];
+    let i = 0;
+    while (i < args.length) {
+        addCodeArg(code, args[i]);
+        code.push(strs[++i]);
+    }
+    return new _Code(code);
+}
+exports._ = _;
+const plus = new _Code("+");
+function str(strs, ...args) {
+    const expr = [safeStringify(strs[0])];
+    let i = 0;
+    while (i < args.length) {
+        expr.push(plus);
+        addCodeArg(expr, args[i]);
+        expr.push(plus, safeStringify(strs[++i]));
+    }
+    optimize(expr);
+    return new _Code(expr);
+}
+exports.str = str;
+function addCodeArg(code, arg) {
+    if (arg instanceof _Code)
+        code.push(...arg._items);
+    else if (arg instanceof Name)
+        code.push(arg);
+    else
+        code.push(interpolate(arg));
+}
+exports.addCodeArg = addCodeArg;
+function optimize(expr) {
+    let i = 1;
+    while (i < expr.length - 1) {
+        if (expr[i] === plus) {
+            const res = mergeExprItems(expr[i - 1], expr[i + 1]);
+            if (res !== undefined) {
+                expr.splice(i - 1, 3, res);
+                continue;
+            }
+            expr[i++] = "+";
+        }
+        i++;
+    }
+}
+function mergeExprItems(a, b) {
+    if (b === '""')
+        return a;
+    if (a === '""')
+        return b;
+    if (typeof a == "string") {
+        if (b instanceof Name || a[a.length - 1] !== '"')
+            return;
+        if (typeof b != "string")
+            return `${a.slice(0, -1)}${b}"`;
+        if (b[0] === '"')
+            return a.slice(0, -1) + b.slice(1);
+        return;
+    }
+    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
+        return `"${a}${b.slice(1)}`;
+    return;
+}
+function strConcat(c1, c2) {
+    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;
+}
+exports.strConcat = strConcat;
+// TODO do not allow arrays here
+function interpolate(x) {
+    return typeof x == "number" || typeof x == "boolean" || x === null
+        ? x
+        : safeStringify(Array.isArray(x) ? x.join(",") : x);
+}
+function stringify(x) {
+    return new _Code(safeStringify(x));
+}
+exports.stringify = stringify;
+function safeStringify(x) {
+    return JSON.stringify(x)
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+}
+exports.safeStringify = safeStringify;
+function getProperty(key) {
+    return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;
+}
+exports.getProperty = getProperty;
+//Does best effort to format the name properly
+function getEsmExportName(key) {
+    if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
+        return new _Code(`${key}`);
+    }
+    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+}
+exports.getEsmExportName = getEsmExportName;
+function regexpCode(rx) {
+    return new _Code(rx.toString());
+}
+exports.regexpCode = regexpCode;
+//# sourceMappingURL=code.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/index.d.ts

@@ -0,0 +1,79 @@
+import type { ScopeValueSets, NameValue, ValueScope, ValueScopeName } from "./scope";
+import { _Code, Code, Name } from "./code";
+import { Scope } from "./scope";
+export { _, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code } from "./code";
+export { Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds } from "./scope";
+export type SafeExpr = Code | number | boolean | null;
+export type Block = Code | (() => void);
+export declare const operators: {
+    GT: _Code;
+    GTE: _Code;
+    LT: _Code;
+    LTE: _Code;
+    EQ: _Code;
+    NEQ: _Code;
+    NOT: _Code;
+    OR: _Code;
+    AND: _Code;
+    ADD: _Code;
+};
+export interface CodeGenOptions {
+    es5?: boolean;
+    lines?: boolean;
+    ownProperties?: boolean;
+}
+export declare class CodeGen {
+    readonly _scope: Scope;
+    readonly _extScope: ValueScope;
+    readonly _values: ScopeValueSets;
+    private readonly _nodes;
+    private readonly _blockStarts;
+    private readonly _constants;
+    private readonly opts;
+    constructor(extScope: ValueScope, opts?: CodeGenOptions);
+    toString(): string;
+    name(prefix: string): Name;
+    scopeName(prefix: string): ValueScopeName;
+    scopeValue(prefixOrName: ValueScopeName | string, value: NameValue): Name;
+    getScopeValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined;
+    scopeRefs(scopeName: Name): Code;
+    scopeCode(): Code;
+    private _def;
+    const(nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean): Name;
+    let(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name;
+    var(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name;
+    assign(lhs: Code, rhs: SafeExpr, sideEffects?: boolean): CodeGen;
+    add(lhs: Code, rhs: SafeExpr): CodeGen;
+    code(c: Block | SafeExpr): CodeGen;
+    object(...keyValues: [Name | string, SafeExpr | string][]): _Code;
+    if(condition: Code | boolean, thenBody?: Block, elseBody?: Block): CodeGen;
+    elseIf(condition: Code | boolean): CodeGen;
+    else(): CodeGen;
+    endIf(): CodeGen;
+    private _for;
+    for(iteration: Code, forBody?: Block): CodeGen;
+    forRange(nameOrPrefix: Name | string, from: SafeExpr, to: SafeExpr, forBody: (index: Name) => void, varKind?: Code): CodeGen;
+    forOf(nameOrPrefix: Name | string, iterable: Code, forBody: (item: Name) => void, varKind?: Code): CodeGen;
+    forIn(nameOrPrefix: Name | string, obj: Code, forBody: (item: Name) => void, varKind?: Code): CodeGen;
+    endFor(): CodeGen;
+    label(label: Name): CodeGen;
+    break(label?: Code): CodeGen;
+    return(value: Block | SafeExpr): CodeGen;
+    try(tryBody: Block, catchCode?: (e: Name) => void, finallyCode?: Block): CodeGen;
+    throw(error: Code): CodeGen;
+    block(body?: Block, nodeCount?: number): CodeGen;
+    endBlock(nodeCount?: number): CodeGen;
+    func(name: Name, args?: Code, async?: boolean, funcBody?: Block): CodeGen;
+    endFunc(): CodeGen;
+    optimize(n?: number): void;
+    private _leafNode;
+    private _blockNode;
+    private _endBlockNode;
+    private _elseNode;
+    private get _root();
+    private get _currNode();
+    private set _currNode(value);
+}
+export declare function not<T extends Code | SafeExpr>(x: T): T;
+export declare function and(...args: Code[]): Code;
+export declare function or(...args: Code[]): Code;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/index.js

@@ -0,0 +1,697 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
+const code_1 = require("./code");
+const scope_1 = require("./scope");
+var code_2 = require("./code");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return code_2._; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return code_2.str; } });
+Object.defineProperty(exports, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } });
+Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return code_2.nil; } });
+Object.defineProperty(exports, "getProperty", { enumerable: true, get: function () { return code_2.getProperty; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return code_2.stringify; } });
+Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function () { return code_2.regexpCode; } });
+Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return code_2.Name; } });
+var scope_2 = require("./scope");
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return scope_2.Scope; } });
+Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function () { return scope_2.ValueScope; } });
+Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function () { return scope_2.ValueScopeName; } });
+Object.defineProperty(exports, "varKinds", { enumerable: true, get: function () { return scope_2.varKinds; } });
+exports.operators = {
+    GT: new code_1._Code(">"),
+    GTE: new code_1._Code(">="),
+    LT: new code_1._Code("<"),
+    LTE: new code_1._Code("<="),
+    EQ: new code_1._Code("==="),
+    NEQ: new code_1._Code("!=="),
+    NOT: new code_1._Code("!"),
+    OR: new code_1._Code("||"),
+    AND: new code_1._Code("&&"),
+    ADD: new code_1._Code("+"),
+};
+class Node {
+    optimizeNodes() {
+        return this;
+    }
+    optimizeNames(_names, _constants) {
+        return this;
+    }
+}
+class Def extends Node {
+    constructor(varKind, name, rhs) {
+        super();
+        this.varKind = varKind;
+        this.name = name;
+        this.rhs = rhs;
+    }
+    render({ es5, _n }) {
+        const varKind = es5 ? scope_1.varKinds.var : this.varKind;
+        const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
+        return `${varKind} ${this.name}${rhs};` + _n;
+    }
+    optimizeNames(names, constants) {
+        if (!names[this.name.str])
+            return;
+        if (this.rhs)
+            this.rhs = optimizeExpr(this.rhs, names, constants);
+        return this;
+    }
+    get names() {
+        return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
+    }
+}
+class Assign extends Node {
+    constructor(lhs, rhs, sideEffects) {
+        super();
+        this.lhs = lhs;
+        this.rhs = rhs;
+        this.sideEffects = sideEffects;
+    }
+    render({ _n }) {
+        return `${this.lhs} = ${this.rhs};` + _n;
+    }
+    optimizeNames(names, constants) {
+        if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
+            return;
+        this.rhs = optimizeExpr(this.rhs, names, constants);
+        return this;
+    }
+    get names() {
+        const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
+        return addExprNames(names, this.rhs);
+    }
+}
+class AssignOp extends Assign {
+    constructor(lhs, op, rhs, sideEffects) {
+        super(lhs, rhs, sideEffects);
+        this.op = op;
+    }
+    render({ _n }) {
+        return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
+    }
+}
+class Label extends Node {
+    constructor(label) {
+        super();
+        this.label = label;
+        this.names = {};
+    }
+    render({ _n }) {
+        return `${this.label}:` + _n;
+    }
+}
+class Break extends Node {
+    constructor(label) {
+        super();
+        this.label = label;
+        this.names = {};
+    }
+    render({ _n }) {
+        const label = this.label ? ` ${this.label}` : "";
+        return `break${label};` + _n;
+    }
+}
+class Throw extends Node {
+    constructor(error) {
+        super();
+        this.error = error;
+    }
+    render({ _n }) {
+        return `throw ${this.error};` + _n;
+    }
+    get names() {
+        return this.error.names;
+    }
+}
+class AnyCode extends Node {
+    constructor(code) {
+        super();
+        this.code = code;
+    }
+    render({ _n }) {
+        return `${this.code};` + _n;
+    }
+    optimizeNodes() {
+        return `${this.code}` ? this : undefined;
+    }
+    optimizeNames(names, constants) {
+        this.code = optimizeExpr(this.code, names, constants);
+        return this;
+    }
+    get names() {
+        return this.code instanceof code_1._CodeOrName ? this.code.names : {};
+    }
+}
+class ParentNode extends Node {
+    constructor(nodes = []) {
+        super();
+        this.nodes = nodes;
+    }
+    render(opts) {
+        return this.nodes.reduce((code, n) => code + n.render(opts), "");
+    }
+    optimizeNodes() {
+        const { nodes } = this;
+        let i = nodes.length;
+        while (i--) {
+            const n = nodes[i].optimizeNodes();
+            if (Array.isArray(n))
+                nodes.splice(i, 1, ...n);
+            else if (n)
+                nodes[i] = n;
+            else
+                nodes.splice(i, 1);
+        }
+        return nodes.length > 0 ? this : undefined;
+    }
+    optimizeNames(names, constants) {
+        const { nodes } = this;
+        let i = nodes.length;
+        while (i--) {
+            // iterating backwards improves 1-pass optimization
+            const n = nodes[i];
+            if (n.optimizeNames(names, constants))
+                continue;
+            subtractNames(names, n.names);
+            nodes.splice(i, 1);
+        }
+        return nodes.length > 0 ? this : undefined;
+    }
+    get names() {
+        return this.nodes.reduce((names, n) => addNames(names, n.names), {});
+    }
+}
+class BlockNode extends ParentNode {
+    render(opts) {
+        return "{" + opts._n + super.render(opts) + "}" + opts._n;
+    }
+}
+class Root extends ParentNode {
+}
+class Else extends BlockNode {
+}
+Else.kind = "else";
+class If extends BlockNode {
+    constructor(condition, nodes) {
+        super(nodes);
+        this.condition = condition;
+    }
+    render(opts) {
+        let code = `if(${this.condition})` + super.render(opts);
+        if (this.else)
+            code += "else " + this.else.render(opts);
+        return code;
+    }
+    optimizeNodes() {
+        super.optimizeNodes();
+        const cond = this.condition;
+        if (cond === true)
+            return this.nodes; // else is ignored here
+        let e = this.else;
+        if (e) {
+            const ns = e.optimizeNodes();
+            e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
+        }
+        if (e) {
+            if (cond === false)
+                return e instanceof If ? e : e.nodes;
+            if (this.nodes.length)
+                return this;
+            return new If(not(cond), e instanceof If ? [e] : e.nodes);
+        }
+        if (cond === false || !this.nodes.length)
+            return undefined;
+        return this;
+    }
+    optimizeNames(names, constants) {
+        var _a;
+        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
+        if (!(super.optimizeNames(names, constants) || this.else))
+            return;
+        this.condition = optimizeExpr(this.condition, names, constants);
+        return this;
+    }
+    get names() {
+        const names = super.names;
+        addExprNames(names, this.condition);
+        if (this.else)
+            addNames(names, this.else.names);
+        return names;
+    }
+}
+If.kind = "if";
+class For extends BlockNode {
+}
+For.kind = "for";
+class ForLoop extends For {
+    constructor(iteration) {
+        super();
+        this.iteration = iteration;
+    }
+    render(opts) {
+        return `for(${this.iteration})` + super.render(opts);
+    }
+    optimizeNames(names, constants) {
+        if (!super.optimizeNames(names, constants))
+            return;
+        this.iteration = optimizeExpr(this.iteration, names, constants);
+        return this;
+    }
+    get names() {
+        return addNames(super.names, this.iteration.names);
+    }
+}
+class ForRange extends For {
+    constructor(varKind, name, from, to) {
+        super();
+        this.varKind = varKind;
+        this.name = name;
+        this.from = from;
+        this.to = to;
+    }
+    render(opts) {
+        const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
+        const { name, from, to } = this;
+        return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
+    }
+    get names() {
+        const names = addExprNames(super.names, this.from);
+        return addExprNames(names, this.to);
+    }
+}
+class ForIter extends For {
+    constructor(loop, varKind, name, iterable) {
+        super();
+        this.loop = loop;
+        this.varKind = varKind;
+        this.name = name;
+        this.iterable = iterable;
+    }
+    render(opts) {
+        return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
+    }
+    optimizeNames(names, constants) {
+        if (!super.optimizeNames(names, constants))
+            return;
+        this.iterable = optimizeExpr(this.iterable, names, constants);
+        return this;
+    }
+    get names() {
+        return addNames(super.names, this.iterable.names);
+    }
+}
+class Func extends BlockNode {
+    constructor(name, args, async) {
+        super();
+        this.name = name;
+        this.args = args;
+        this.async = async;
+    }
+    render(opts) {
+        const _async = this.async ? "async " : "";
+        return `${_async}function ${this.name}(${this.args})` + super.render(opts);
+    }
+}
+Func.kind = "func";
+class Return extends ParentNode {
+    render(opts) {
+        return "return " + super.render(opts);
+    }
+}
+Return.kind = "return";
+class Try extends BlockNode {
+    render(opts) {
+        let code = "try" + super.render(opts);
+        if (this.catch)
+            code += this.catch.render(opts);
+        if (this.finally)
+            code += this.finally.render(opts);
+        return code;
+    }
+    optimizeNodes() {
+        var _a, _b;
+        super.optimizeNodes();
+        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
+        return this;
+    }
+    optimizeNames(names, constants) {
+        var _a, _b;
+        super.optimizeNames(names, constants);
+        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
+        return this;
+    }
+    get names() {
+        const names = super.names;
+        if (this.catch)
+            addNames(names, this.catch.names);
+        if (this.finally)
+            addNames(names, this.finally.names);
+        return names;
+    }
+}
+class Catch extends BlockNode {
+    constructor(error) {
+        super();
+        this.error = error;
+    }
+    render(opts) {
+        return `catch(${this.error})` + super.render(opts);
+    }
+}
+Catch.kind = "catch";
+class Finally extends BlockNode {
+    render(opts) {
+        return "finally" + super.render(opts);
+    }
+}
+Finally.kind = "finally";
+class CodeGen {
+    constructor(extScope, opts = {}) {
+        this._values = {};
+        this._blockStarts = [];
+        this._constants = {};
+        this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
+        this._extScope = extScope;
+        this._scope = new scope_1.Scope({ parent: extScope });
+        this._nodes = [new Root()];
+    }
+    toString() {
+        return this._root.render(this.opts);
+    }
+    // returns unique name in the internal scope
+    name(prefix) {
+        return this._scope.name(prefix);
+    }
+    // reserves unique name in the external scope
+    scopeName(prefix) {
+        return this._extScope.name(prefix);
+    }
+    // reserves unique name in the external scope and assigns value to it
+    scopeValue(prefixOrName, value) {
+        const name = this._extScope.value(prefixOrName, value);
+        const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set());
+        vs.add(name);
+        return name;
+    }
+    getScopeValue(prefix, keyOrRef) {
+        return this._extScope.getValue(prefix, keyOrRef);
+    }
+    // return code that assigns values in the external scope to the names that are used internally
+    // (same names that were returned by gen.scopeName or gen.scopeValue)
+    scopeRefs(scopeName) {
+        return this._extScope.scopeRefs(scopeName, this._values);
+    }
+    scopeCode() {
+        return this._extScope.scopeCode(this._values);
+    }
+    _def(varKind, nameOrPrefix, rhs, constant) {
+        const name = this._scope.toName(nameOrPrefix);
+        if (rhs !== undefined && constant)
+            this._constants[name.str] = rhs;
+        this._leafNode(new Def(varKind, name, rhs));
+        return name;
+    }
+    // `const` declaration (`var` in es5 mode)
+    const(nameOrPrefix, rhs, _constant) {
+        return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
+    }
+    // `let` declaration with optional assignment (`var` in es5 mode)
+    let(nameOrPrefix, rhs, _constant) {
+        return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
+    }
+    // `var` declaration with optional assignment
+    var(nameOrPrefix, rhs, _constant) {
+        return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
+    }
+    // assignment code
+    assign(lhs, rhs, sideEffects) {
+        return this._leafNode(new Assign(lhs, rhs, sideEffects));
+    }
+    // `+=` code
+    add(lhs, rhs) {
+        return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
+    }
+    // appends passed SafeExpr to code or executes Block
+    code(c) {
+        if (typeof c == "function")
+            c();
+        else if (c !== code_1.nil)
+            this._leafNode(new AnyCode(c));
+        return this;
+    }
+    // returns code for object literal for the passed argument list of key-value pairs
+    object(...keyValues) {
+        const code = ["{"];
+        for (const [key, value] of keyValues) {
+            if (code.length > 1)
+                code.push(",");
+            code.push(key);
+            if (key !== value || this.opts.es5) {
+                code.push(":");
+                (0, code_1.addCodeArg)(code, value);
+            }
+        }
+        code.push("}");
+        return new code_1._Code(code);
+    }
+    // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
+    if(condition, thenBody, elseBody) {
+        this._blockNode(new If(condition));
+        if (thenBody && elseBody) {
+            this.code(thenBody).else().code(elseBody).endIf();
+        }
+        else if (thenBody) {
+            this.code(thenBody).endIf();
+        }
+        else if (elseBody) {
+            throw new Error('CodeGen: "else" body without "then" body');
+        }
+        return this;
+    }
+    // `else if` clause - invalid without `if` or after `else` clauses
+    elseIf(condition) {
+        return this._elseNode(new If(condition));
+    }
+    // `else` clause - only valid after `if` or `else if` clauses
+    else() {
+        return this._elseNode(new Else());
+    }
+    // end `if` statement (needed if gen.if was used only with condition)
+    endIf() {
+        return this._endBlockNode(If, Else);
+    }
+    _for(node, forBody) {
+        this._blockNode(node);
+        if (forBody)
+            this.code(forBody).endFor();
+        return this;
+    }
+    // a generic `for` clause (or statement if `forBody` is passed)
+    for(iteration, forBody) {
+        return this._for(new ForLoop(iteration), forBody);
+    }
+    // `for` statement for a range of values
+    forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
+        const name = this._scope.toName(nameOrPrefix);
+        return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
+    }
+    // `for-of` statement (in es5 mode replace with a normal for loop)
+    forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
+        const name = this._scope.toName(nameOrPrefix);
+        if (this.opts.es5) {
+            const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
+            return this.forRange("_i", 0, (0, code_1._) `${arr}.length`, (i) => {
+                this.var(name, (0, code_1._) `${arr}[${i}]`);
+                forBody(name);
+            });
+        }
+        return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
+    }
+    // `for-in` statement.
+    // With option `ownProperties` replaced with a `for-of` loop for object keys
+    forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
+        if (this.opts.ownProperties) {
+            return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody);
+        }
+        const name = this._scope.toName(nameOrPrefix);
+        return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
+    }
+    // end `for` loop
+    endFor() {
+        return this._endBlockNode(For);
+    }
+    // `label` statement
+    label(label) {
+        return this._leafNode(new Label(label));
+    }
+    // `break` statement
+    break(label) {
+        return this._leafNode(new Break(label));
+    }
+    // `return` statement
+    return(value) {
+        const node = new Return();
+        this._blockNode(node);
+        this.code(value);
+        if (node.nodes.length !== 1)
+            throw new Error('CodeGen: "return" should have one node');
+        return this._endBlockNode(Return);
+    }
+    // `try` statement
+    try(tryBody, catchCode, finallyCode) {
+        if (!catchCode && !finallyCode)
+            throw new Error('CodeGen: "try" without "catch" and "finally"');
+        const node = new Try();
+        this._blockNode(node);
+        this.code(tryBody);
+        if (catchCode) {
+            const error = this.name("e");
+            this._currNode = node.catch = new Catch(error);
+            catchCode(error);
+        }
+        if (finallyCode) {
+            this._currNode = node.finally = new Finally();
+            this.code(finallyCode);
+        }
+        return this._endBlockNode(Catch, Finally);
+    }
+    // `throw` statement
+    throw(error) {
+        return this._leafNode(new Throw(error));
+    }
+    // start self-balancing block
+    block(body, nodeCount) {
+        this._blockStarts.push(this._nodes.length);
+        if (body)
+            this.code(body).endBlock(nodeCount);
+        return this;
+    }
+    // end the current self-balancing block
+    endBlock(nodeCount) {
+        const len = this._blockStarts.pop();
+        if (len === undefined)
+            throw new Error("CodeGen: not in self-balancing block");
+        const toClose = this._nodes.length - len;
+        if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) {
+            throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
+        }
+        this._nodes.length = len;
+        return this;
+    }
+    // `function` heading (or definition if funcBody is passed)
+    func(name, args = code_1.nil, async, funcBody) {
+        this._blockNode(new Func(name, args, async));
+        if (funcBody)
+            this.code(funcBody).endFunc();
+        return this;
+    }
+    // end function definition
+    endFunc() {
+        return this._endBlockNode(Func);
+    }
+    optimize(n = 1) {
+        while (n-- > 0) {
+            this._root.optimizeNodes();
+            this._root.optimizeNames(this._root.names, this._constants);
+        }
+    }
+    _leafNode(node) {
+        this._currNode.nodes.push(node);
+        return this;
+    }
+    _blockNode(node) {
+        this._currNode.nodes.push(node);
+        this._nodes.push(node);
+    }
+    _endBlockNode(N1, N2) {
+        const n = this._currNode;
+        if (n instanceof N1 || (N2 && n instanceof N2)) {
+            this._nodes.pop();
+            return this;
+        }
+        throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
+    }
+    _elseNode(node) {
+        const n = this._currNode;
+        if (!(n instanceof If)) {
+            throw new Error('CodeGen: "else" without "if"');
+        }
+        this._currNode = n.else = node;
+        return this;
+    }
+    get _root() {
+        return this._nodes[0];
+    }
+    get _currNode() {
+        const ns = this._nodes;
+        return ns[ns.length - 1];
+    }
+    set _currNode(node) {
+        const ns = this._nodes;
+        ns[ns.length - 1] = node;
+    }
+}
+exports.CodeGen = CodeGen;
+function addNames(names, from) {
+    for (const n in from)
+        names[n] = (names[n] || 0) + (from[n] || 0);
+    return names;
+}
+function addExprNames(names, from) {
+    return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
+}
+function optimizeExpr(expr, names, constants) {
+    if (expr instanceof code_1.Name)
+        return replaceName(expr);
+    if (!canOptimize(expr))
+        return expr;
+    return new code_1._Code(expr._items.reduce((items, c) => {
+        if (c instanceof code_1.Name)
+            c = replaceName(c);
+        if (c instanceof code_1._Code)
+            items.push(...c._items);
+        else
+            items.push(c);
+        return items;
+    }, []));
+    function replaceName(n) {
+        const c = constants[n.str];
+        if (c === undefined || names[n.str] !== 1)
+            return n;
+        delete names[n.str];
+        return c;
+    }
+    function canOptimize(e) {
+        return (e instanceof code_1._Code &&
+            e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined));
+    }
+}
+function subtractNames(names, from) {
+    for (const n in from)
+        names[n] = (names[n] || 0) - (from[n] || 0);
+}
+function not(x) {
+    return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._) `!${par(x)}`;
+}
+exports.not = not;
+const andCode = mappend(exports.operators.AND);
+// boolean AND (&&) expression with the passed arguments
+function and(...args) {
+    return args.reduce(andCode);
+}
+exports.and = and;
+const orCode = mappend(exports.operators.OR);
+// boolean OR (||) expression with the passed arguments
+function or(...args) {
+    return args.reduce(orCode);
+}
+exports.or = or;
+function mappend(op) {
+    return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`);
+}
+function par(x) {
+    return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`;
+}
+//# sourceMappingURL=index.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/scope.d.ts

@@ -0,0 +1,79 @@
+import { Code, Name } from "./code";
+interface NameGroup {
+    prefix: string;
+    index: number;
+}
+export interface NameValue {
+    ref: ValueReference;
+    key?: unknown;
+    code?: Code;
+}
+export type ValueReference = unknown;
+interface ScopeOptions {
+    prefixes?: Set<string>;
+    parent?: Scope;
+}
+interface ValueScopeOptions extends ScopeOptions {
+    scope: ScopeStore;
+    es5?: boolean;
+    lines?: boolean;
+}
+export type ScopeStore = Record<string, ValueReference[] | undefined>;
+type ScopeValues = {
+    [Prefix in string]?: Map<unknown, ValueScopeName>;
+};
+export type ScopeValueSets = {
+    [Prefix in string]?: Set<ValueScopeName>;
+};
+export declare enum UsedValueState {
+    Started = 0,
+    Completed = 1
+}
+export type UsedScopeValues = {
+    [Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined>;
+};
+export declare const varKinds: {
+    const: Name;
+    let: Name;
+    var: Name;
+};
+export declare class Scope {
+    protected readonly _names: {
+        [Prefix in string]?: NameGroup;
+    };
+    protected readonly _prefixes?: Set<string>;
+    protected readonly _parent?: Scope;
+    constructor({ prefixes, parent }?: ScopeOptions);
+    toName(nameOrPrefix: Name | string): Name;
+    name(prefix: string): Name;
+    protected _newName(prefix: string): string;
+    private _nameGroup;
+}
+interface ScopePath {
+    property: string;
+    itemIndex: number;
+}
+export declare class ValueScopeName extends Name {
+    readonly prefix: string;
+    value?: NameValue;
+    scopePath?: Code;
+    constructor(prefix: string, nameStr: string);
+    setValue(value: NameValue, { property, itemIndex }: ScopePath): void;
+}
+interface VSOptions extends ValueScopeOptions {
+    _n: Code;
+}
+export declare class ValueScope extends Scope {
+    protected readonly _values: ScopeValues;
+    protected readonly _scope: ScopeStore;
+    readonly opts: VSOptions;
+    constructor(opts: ValueScopeOptions);
+    get(): ScopeStore;
+    name(prefix: string): ValueScopeName;
+    value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName;
+    getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined;
+    scopeRefs(scopeName: Name, values?: ScopeValues | ScopeValueSets): Code;
+    scopeCode(values?: ScopeValues | ScopeValueSets, usedValues?: UsedScopeValues, getCode?: (n: ValueScopeName) => Code | undefined): Code;
+    private _reduceValues;
+}
+export {};

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/codegen/scope.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
+const code_1 = require("./code");
+class ValueError extends Error {
+    constructor(name) {
+        super(`CodeGen: "code" for ${name} not defined`);
+        this.value = name.value;
+    }
+}
+var UsedValueState;
+(function (UsedValueState) {
+    UsedValueState[UsedValueState["Started"] = 0] = "Started";
+    UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
+})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
+exports.varKinds = {
+    const: new code_1.Name("const"),
+    let: new code_1.Name("let"),
+    var: new code_1.Name("var"),
+};
+class Scope {
+    constructor({ prefixes, parent } = {}) {
+        this._names = {};
+        this._prefixes = prefixes;
+        this._parent = parent;
+    }
+    toName(nameOrPrefix) {
+        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
+    }
+    name(prefix) {
+        return new code_1.Name(this._newName(prefix));
+    }
+    _newName(prefix) {
+        const ng = this._names[prefix] || this._nameGroup(prefix);
+        return `${prefix}${ng.index++}`;
+    }
+    _nameGroup(prefix) {
+        var _a, _b;
+        if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) {
+            throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
+        }
+        return (this._names[prefix] = { prefix, index: 0 });
+    }
+}
+exports.Scope = Scope;
+class ValueScopeName extends code_1.Name {
+    constructor(prefix, nameStr) {
+        super(nameStr);
+        this.prefix = prefix;
+    }
+    setValue(value, { property, itemIndex }) {
+        this.value = value;
+        this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`;
+    }
+}
+exports.ValueScopeName = ValueScopeName;
+const line = (0, code_1._) `\n`;
+class ValueScope extends Scope {
+    constructor(opts) {
+        super(opts);
+        this._values = {};
+        this._scope = opts.scope;
+        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
+    }
+    get() {
+        return this._scope;
+    }
+    name(prefix) {
+        return new ValueScopeName(prefix, this._newName(prefix));
+    }
+    value(nameOrPrefix, value) {
+        var _a;
+        if (value.ref === undefined)
+            throw new Error("CodeGen: ref must be passed in value");
+        const name = this.toName(nameOrPrefix);
+        const { prefix } = name;
+        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
+        let vs = this._values[prefix];
+        if (vs) {
+            const _name = vs.get(valueKey);
+            if (_name)
+                return _name;
+        }
+        else {
+            vs = this._values[prefix] = new Map();
+        }
+        vs.set(valueKey, name);
+        const s = this._scope[prefix] || (this._scope[prefix] = []);
+        const itemIndex = s.length;
+        s[itemIndex] = value.ref;
+        name.setValue(value, { property: prefix, itemIndex });
+        return name;
+    }
+    getValue(prefix, keyOrRef) {
+        const vs = this._values[prefix];
+        if (!vs)
+            return;
+        return vs.get(keyOrRef);
+    }
+    scopeRefs(scopeName, values = this._values) {
+        return this._reduceValues(values, (name) => {
+            if (name.scopePath === undefined)
+                throw new Error(`CodeGen: name "${name}" has no value`);
+            return (0, code_1._) `${scopeName}${name.scopePath}`;
+        });
+    }
+    scopeCode(values = this._values, usedValues, getCode) {
+        return this._reduceValues(values, (name) => {
+            if (name.value === undefined)
+                throw new Error(`CodeGen: name "${name}" has no value`);
+            return name.value.code;
+        }, usedValues, getCode);
+    }
+    _reduceValues(values, valueCode, usedValues = {}, getCode) {
+        let code = code_1.nil;
+        for (const prefix in values) {
+            const vs = values[prefix];
+            if (!vs)
+                continue;
+            const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map());
+            vs.forEach((name) => {
+                if (nameSet.has(name))
+                    return;
+                nameSet.set(name, UsedValueState.Started);
+                let c = valueCode(name);
+                if (c) {
+                    const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
+                    code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`;
+                }
+                else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) {
+                    code = (0, code_1._) `${code}${c}${this.opts._n}`;
+                }
+                else {
+                    throw new ValueError(name);
+                }
+                nameSet.set(name, UsedValueState.Completed);
+            });
+        }
+        return code;
+    }
+}
+exports.ValueScope = ValueScope;
+//# sourceMappingURL=scope.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/errors.d.ts

@@ -0,0 +1,13 @@
+import type { KeywordErrorCxt, KeywordErrorDefinition } from "../types";
+import { CodeGen, Code, Name } from "./codegen";
+export declare const keywordError: KeywordErrorDefinition;
+export declare const keyword$DataError: KeywordErrorDefinition;
+export interface ErrorPaths {
+    instancePath?: Code;
+    schemaPath?: string;
+    parentSchema?: boolean;
+}
+export declare function reportError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths, overrideAllErrors?: boolean): void;
+export declare function reportExtraError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths): void;
+export declare function resetErrorsCount(gen: CodeGen, errsCount: Name): void;
+export declare function extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }: KeywordErrorCxt): void;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/errors.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
+const codegen_1 = require("./codegen");
+const util_1 = require("./util");
+const names_1 = require("./names");
+exports.keywordError = {
+    message: ({ keyword }) => (0, codegen_1.str) `must pass "${keyword}" keyword validation`,
+};
+exports.keyword$DataError = {
+    message: ({ keyword, schemaType }) => schemaType
+        ? (0, codegen_1.str) `"${keyword}" keyword must be ${schemaType} ($data)`
+        : (0, codegen_1.str) `"${keyword}" keyword is invalid ($data)`,
+};
+function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
+    const { it } = cxt;
+    const { gen, compositeRule, allErrors } = it;
+    const errObj = errorObjectCode(cxt, error, errorPaths);
+    if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : (compositeRule || allErrors)) {
+        addError(gen, errObj);
+    }
+    else {
+        returnErrors(it, (0, codegen_1._) `[${errObj}]`);
+    }
+}
+exports.reportError = reportError;
+function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
+    const { it } = cxt;
+    const { gen, compositeRule, allErrors } = it;
+    const errObj = errorObjectCode(cxt, error, errorPaths);
+    addError(gen, errObj);
+    if (!(compositeRule || allErrors)) {
+        returnErrors(it, names_1.default.vErrors);
+    }
+}
+exports.reportExtraError = reportExtraError;
+function resetErrorsCount(gen, errsCount) {
+    gen.assign(names_1.default.errors, errsCount);
+    gen.if((0, codegen_1._) `${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._) `${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
+}
+exports.resetErrorsCount = resetErrorsCount;
+function extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }) {
+    /* istanbul ignore if */
+    if (errsCount === undefined)
+        throw new Error("ajv implementation error");
+    const err = gen.name("err");
+    gen.forRange("i", errsCount, names_1.default.errors, (i) => {
+        gen.const(err, (0, codegen_1._) `${names_1.default.vErrors}[${i}]`);
+        gen.if((0, codegen_1._) `${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._) `${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+        gen.assign((0, codegen_1._) `${err}.schemaPath`, (0, codegen_1.str) `${it.errSchemaPath}/${keyword}`);
+        if (it.opts.verbose) {
+            gen.assign((0, codegen_1._) `${err}.schema`, schemaValue);
+            gen.assign((0, codegen_1._) `${err}.data`, data);
+        }
+    });
+}
+exports.extendErrors = extendErrors;
+function addError(gen, errObj) {
+    const err = gen.const("err", errObj);
+    gen.if((0, codegen_1._) `${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._) `[${err}]`), (0, codegen_1._) `${names_1.default.vErrors}.push(${err})`);
+    gen.code((0, codegen_1._) `${names_1.default.errors}++`);
+}
+function returnErrors(it, errs) {
+    const { gen, validateName, schemaEnv } = it;
+    if (schemaEnv.$async) {
+        gen.throw((0, codegen_1._) `new ${it.ValidationError}(${errs})`);
+    }
+    else {
+        gen.assign((0, codegen_1._) `${validateName}.errors`, errs);
+        gen.return(false);
+    }
+}
+const E = {
+    keyword: new codegen_1.Name("keyword"),
+    schemaPath: new codegen_1.Name("schemaPath"), // also used in JTD errors
+    params: new codegen_1.Name("params"),
+    propertyName: new codegen_1.Name("propertyName"),
+    message: new codegen_1.Name("message"),
+    schema: new codegen_1.Name("schema"),
+    parentSchema: new codegen_1.Name("parentSchema"),
+};
+function errorObjectCode(cxt, error, errorPaths) {
+    const { createErrors } = cxt.it;
+    if (createErrors === false)
+        return (0, codegen_1._) `{}`;
+    return errorObject(cxt, error, errorPaths);
+}
+function errorObject(cxt, error, errorPaths = {}) {
+    const { gen, it } = cxt;
+    const keyValues = [
+        errorInstancePath(it, errorPaths),
+        errorSchemaPath(cxt, errorPaths),
+    ];
+    extraErrorProps(cxt, error, keyValues);
+    return gen.object(...keyValues);
+}
+function errorInstancePath({ errorPath }, { instancePath }) {
+    const instPath = instancePath
+        ? (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
+        : errorPath;
+    return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
+}
+function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
+    let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str) `${errSchemaPath}/${keyword}`;
+    if (schemaPath) {
+        schPath = (0, codegen_1.str) `${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
+    }
+    return [E.schemaPath, schPath];
+}
+function extraErrorProps(cxt, { params, message }, keyValues) {
+    const { keyword, data, schemaValue, it } = cxt;
+    const { opts, propertyName, topSchemaRef, schemaPath } = it;
+    keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._) `{}`]);
+    if (opts.messages) {
+        keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
+    }
+    if (opts.verbose) {
+        keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._) `${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
+    }
+    if (propertyName)
+        keyValues.push([E.propertyName, propertyName]);
+}
+//# sourceMappingURL=errors.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/index.d.ts

@@ -0,0 +1,80 @@
+import type { AnySchema, AnySchemaObject, AnyValidateFunction, EvaluatedProperties, EvaluatedItems } from "../types";
+import type Ajv from "../core";
+import type { InstanceOptions } from "../core";
+import { CodeGen, Name, Code, ValueScopeName } from "./codegen";
+import { LocalRefs } from "./resolve";
+import { JSONType } from "./rules";
+export type SchemaRefs = {
+    [Ref in string]?: SchemaEnv | AnySchema;
+};
+export interface SchemaCxt {
+    readonly gen: CodeGen;
+    readonly allErrors?: boolean;
+    readonly data: Name;
+    readonly parentData: Name;
+    readonly parentDataProperty: Code | number;
+    readonly dataNames: Name[];
+    readonly dataPathArr: (Code | number)[];
+    readonly dataLevel: number;
+    dataTypes: JSONType[];
+    definedProperties: Set<string>;
+    readonly topSchemaRef: Code;
+    readonly validateName: Name;
+    evaluated?: Name;
+    readonly ValidationError?: Name;
+    readonly schema: AnySchema;
+    readonly schemaEnv: SchemaEnv;
+    readonly rootId: string;
+    baseId: string;
+    readonly schemaPath: Code;
+    readonly errSchemaPath: string;
+    readonly errorPath: Code;
+    readonly propertyName?: Name;
+    readonly compositeRule?: boolean;
+    props?: EvaluatedProperties | Name;
+    items?: EvaluatedItems | Name;
+    jtdDiscriminator?: string;
+    jtdMetadata?: boolean;
+    readonly createErrors?: boolean;
+    readonly opts: InstanceOptions;
+    readonly self: Ajv;
+}
+export interface SchemaObjCxt extends SchemaCxt {
+    readonly schema: AnySchemaObject;
+}
+interface SchemaEnvArgs {
+    readonly schema: AnySchema;
+    readonly schemaId?: "$id" | "id";
+    readonly root?: SchemaEnv;
+    readonly baseId?: string;
+    readonly schemaPath?: string;
+    readonly localRefs?: LocalRefs;
+    readonly meta?: boolean;
+}
+export declare class SchemaEnv implements SchemaEnvArgs {
+    readonly schema: AnySchema;
+    readonly schemaId?: "$id" | "id";
+    readonly root: SchemaEnv;
+    baseId: string;
+    schemaPath?: string;
+    localRefs?: LocalRefs;
+    readonly meta?: boolean;
+    readonly $async?: boolean;
+    readonly refs: SchemaRefs;
+    readonly dynamicAnchors: {
+        [Ref in string]?: true;
+    };
+    validate?: AnyValidateFunction;
+    validateName?: ValueScopeName;
+    serialize?: (data: unknown) => string;
+    serializeName?: ValueScopeName;
+    parse?: (data: string) => unknown;
+    parseName?: ValueScopeName;
+    constructor(env: SchemaEnvArgs);
+}
+export declare function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv;
+export declare function resolveRef(this: Ajv, root: SchemaEnv, baseId: string, ref: string): AnySchema | SchemaEnv | undefined;
+export declare function getCompilingSchema(this: Ajv, schEnv: SchemaEnv): SchemaEnv | void;
+export declare function resolveSchema(this: Ajv, root: SchemaEnv, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
+ref: string): SchemaEnv | undefined;
+export {};

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/index.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
+const codegen_1 = require("./codegen");
+const validation_error_1 = require("../runtime/validation_error");
+const names_1 = require("./names");
+const resolve_1 = require("./resolve");
+const util_1 = require("./util");
+const validate_1 = require("./validate");
+class SchemaEnv {
+    constructor(env) {
+        var _a;
+        this.refs = {};
+        this.dynamicAnchors = {};
+        let schema;
+        if (typeof env.schema == "object")
+            schema = env.schema;
+        this.schema = env.schema;
+        this.schemaId = env.schemaId;
+        this.root = env.root || this;
+        this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
+        this.schemaPath = env.schemaPath;
+        this.localRefs = env.localRefs;
+        this.meta = env.meta;
+        this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
+        this.refs = {};
+    }
+}
+exports.SchemaEnv = SchemaEnv;
+// let codeSize = 0
+// let nodeCount = 0
+// Compiles schema in SchemaEnv
+function compileSchema(sch) {
+    // TODO refactor - remove compilations
+    const _sch = getCompilingSchema.call(this, sch);
+    if (_sch)
+        return _sch;
+    const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); // TODO if getFullPath removed 1 tests fails
+    const { es5, lines } = this.opts.code;
+    const { ownProperties } = this.opts;
+    const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
+    let _ValidationError;
+    if (sch.$async) {
+        _ValidationError = gen.scopeValue("Error", {
+            ref: validation_error_1.default,
+            code: (0, codegen_1._) `require("ajv/dist/runtime/validation_error").default`,
+        });
+    }
+    const validateName = gen.scopeName("validate");
+    sch.validateName = validateName;
+    const schemaCxt = {
+        gen,
+        allErrors: this.opts.allErrors,
+        data: names_1.default.data,
+        parentData: names_1.default.parentData,
+        parentDataProperty: names_1.default.parentDataProperty,
+        dataNames: [names_1.default.data],
+        dataPathArr: [codegen_1.nil], // TODO can its length be used as dataLevel if nil is removed?
+        dataLevel: 0,
+        dataTypes: [],
+        definedProperties: new Set(),
+        topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true
+            ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) }
+            : { ref: sch.schema }),
+        validateName,
+        ValidationError: _ValidationError,
+        schema: sch.schema,
+        schemaEnv: sch,
+        rootId,
+        baseId: sch.baseId || rootId,
+        schemaPath: codegen_1.nil,
+        errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
+        errorPath: (0, codegen_1._) `""`,
+        opts: this.opts,
+        self: this,
+    };
+    let sourceCode;
+    try {
+        this._compilations.add(sch);
+        (0, validate_1.validateFunctionCode)(schemaCxt);
+        gen.optimize(this.opts.code.optimize);
+        // gen.optimize(1)
+        const validateCode = gen.toString();
+        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
+        // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))
+        if (this.opts.code.process)
+            sourceCode = this.opts.code.process(sourceCode, sch);
+        // console.log("\n\n\n *** \n", sourceCode)
+        const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
+        const validate = makeValidate(this, this.scope.get());
+        this.scope.value(validateName, { ref: validate });
+        validate.errors = null;
+        validate.schema = sch.schema;
+        validate.schemaEnv = sch;
+        if (sch.$async)
+            validate.$async = true;
+        if (this.opts.code.source === true) {
+            validate.source = { validateName, validateCode, scopeValues: gen._values };
+        }
+        if (this.opts.unevaluated) {
+            const { props, items } = schemaCxt;
+            validate.evaluated = {
+                props: props instanceof codegen_1.Name ? undefined : props,
+                items: items instanceof codegen_1.Name ? undefined : items,
+                dynamicProps: props instanceof codegen_1.Name,
+                dynamicItems: items instanceof codegen_1.Name,
+            };
+            if (validate.source)
+                validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
+        }
+        sch.validate = validate;
+        return sch;
+    }
+    catch (e) {
+        delete sch.validate;
+        delete sch.validateName;
+        if (sourceCode)
+            this.logger.error("Error compiling schema, function code:", sourceCode);
+        // console.log("\n\n\n *** \n", sourceCode, this.opts)
+        throw e;
+    }
+    finally {
+        this._compilations.delete(sch);
+    }
+}
+exports.compileSchema = compileSchema;
+function resolveRef(root, baseId, ref) {
+    var _a;
+    ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
+    const schOrFunc = root.refs[ref];
+    if (schOrFunc)
+        return schOrFunc;
+    let _sch = resolve.call(this, root, ref);
+    if (_sch === undefined) {
+        const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref]; // TODO maybe localRefs should hold SchemaEnv
+        const { schemaId } = this.opts;
+        if (schema)
+            _sch = new SchemaEnv({ schema, schemaId, root, baseId });
+    }
+    if (_sch === undefined)
+        return;
+    return (root.refs[ref] = inlineOrCompile.call(this, _sch));
+}
+exports.resolveRef = resolveRef;
+function inlineOrCompile(sch) {
+    if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
+        return sch.schema;
+    return sch.validate ? sch : compileSchema.call(this, sch);
+}
+// Index of schema compilation in the currently compiled list
+function getCompilingSchema(schEnv) {
+    for (const sch of this._compilations) {
+        if (sameSchemaEnv(sch, schEnv))
+            return sch;
+    }
+}
+exports.getCompilingSchema = getCompilingSchema;
+function sameSchemaEnv(s1, s2) {
+    return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
+}
+// resolve and compile the references ($ref)
+// TODO returns AnySchemaObject (if the schema can be inlined) or validation function
+function resolve(root, // information about the root schema for the current schema
+ref // reference to resolve
+) {
+    let sch;
+    while (typeof (sch = this.refs[ref]) == "string")
+        ref = sch;
+    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
+}
+// Resolve schema, its root and baseId
+function resolveSchema(root, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
+ref // reference to resolve
+) {
+    const p = this.opts.uriResolver.parse(ref);
+    const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
+    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, undefined);
+    // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests
+    if (Object.keys(root.schema).length > 0 && refPath === baseId) {
+        return getJsonPointer.call(this, p, root);
+    }
+    const id = (0, resolve_1.normalizeId)(refPath);
+    const schOrRef = this.refs[id] || this.schemas[id];
+    if (typeof schOrRef == "string") {
+        const sch = resolveSchema.call(this, root, schOrRef);
+        if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
+            return;
+        return getJsonPointer.call(this, p, sch);
+    }
+    if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
+        return;
+    if (!schOrRef.validate)
+        compileSchema.call(this, schOrRef);
+    if (id === (0, resolve_1.normalizeId)(ref)) {
+        const { schema } = schOrRef;
+        const { schemaId } = this.opts;
+        const schId = schema[schemaId];
+        if (schId)
+            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+        return new SchemaEnv({ schema, schemaId, root, baseId });
+    }
+    return getJsonPointer.call(this, p, schOrRef);
+}
+exports.resolveSchema = resolveSchema;
+const PREVENT_SCOPE_CHANGE = new Set([
+    "properties",
+    "patternProperties",
+    "enum",
+    "dependencies",
+    "definitions",
+]);
+function getJsonPointer(parsedRef, { baseId, schema, root }) {
+    var _a;
+    if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
+        return;
+    for (const part of parsedRef.fragment.slice(1).split("/")) {
+        if (typeof schema === "boolean")
+            return;
+        const partSchema = schema[(0, util_1.unescapeFragment)(part)];
+        if (partSchema === undefined)
+            return;
+        schema = partSchema;
+        // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?
+        const schId = typeof schema === "object" && schema[this.opts.schemaId];
+        if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
+            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+        }
+    }
+    let env;
+    if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
+        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
+        env = resolveSchema.call(this, root, $ref);
+    }
+    // even though resolution failed we need to return SchemaEnv to throw exception
+    // so that compileAsync loads missing schema.
+    const { schemaId } = this.opts;
+    env = env || new SchemaEnv({ schema, schemaId, root, baseId });
+    if (env.schema !== env.root.schema)
+        return env;
+    return undefined;
+}
+//# sourceMappingURL=index.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/parse.d.ts

@@ -0,0 +1,4 @@
+import type Ajv from "../../core";
+import { SchemaObjectMap } from "./types";
+import { SchemaEnv } from "..";
+export default function compileParser(this: Ajv, sch: SchemaEnv, definitions: SchemaObjectMap): SchemaEnv;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/parse.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const __1 = require("..");
+const codegen_1 = require("../codegen");
+const ref_error_1 = require("../ref_error");
+const names_1 = require("../names");
+const code_1 = require("../../vocabularies/code");
+const ref_1 = require("../../vocabularies/jtd/ref");
+const type_1 = require("../../vocabularies/jtd/type");
+const parseJson_1 = require("../../runtime/parseJson");
+const util_1 = require("../util");
+const timestamp_1 = require("../../runtime/timestamp");
+const genParse = {
+    elements: parseElements,
+    values: parseValues,
+    discriminator: parseDiscriminator,
+    properties: parseProperties,
+    optionalProperties: parseProperties,
+    enum: parseEnum,
+    type: parseType,
+    ref: parseRef,
+};
+function compileParser(sch, definitions) {
+    const _sch = __1.getCompilingSchema.call(this, sch);
+    if (_sch)
+        return _sch;
+    const { es5, lines } = this.opts.code;
+    const { ownProperties } = this.opts;
+    const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
+    const parseName = gen.scopeName("parse");
+    const cxt = {
+        self: this,
+        gen,
+        schema: sch.schema,
+        schemaEnv: sch,
+        definitions,
+        data: names_1.default.data,
+        parseName,
+        char: gen.name("c"),
+    };
+    let sourceCode;
+    try {
+        this._compilations.add(sch);
+        sch.parseName = parseName;
+        parserFunction(cxt);
+        gen.optimize(this.opts.code.optimize);
+        const parseFuncCode = gen.toString();
+        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${parseFuncCode}`;
+        const makeParse = new Function(`${names_1.default.scope}`, sourceCode);
+        const parse = makeParse(this.scope.get());
+        this.scope.value(parseName, { ref: parse });
+        sch.parse = parse;
+    }
+    catch (e) {
+        if (sourceCode)
+            this.logger.error("Error compiling parser, function code:", sourceCode);
+        delete sch.parse;
+        delete sch.parseName;
+        throw e;
+    }
+    finally {
+        this._compilations.delete(sch);
+    }
+    return sch;
+}
+exports.default = compileParser;
+const undef = (0, codegen_1._) `undefined`;
+function parserFunction(cxt) {
+    const { gen, parseName, char } = cxt;
+    gen.func(parseName, (0, codegen_1._) `${names_1.default.json}, ${names_1.default.jsonPos}, ${names_1.default.jsonPart}`, false, () => {
+        gen.let(names_1.default.data);
+        gen.let(char);
+        gen.assign((0, codegen_1._) `${parseName}.message`, undef);
+        gen.assign((0, codegen_1._) `${parseName}.position`, undef);
+        gen.assign(names_1.default.jsonPos, (0, codegen_1._) `${names_1.default.jsonPos} || 0`);
+        gen.const(names_1.default.jsonLen, (0, codegen_1._) `${names_1.default.json}.length`);
+        parseCode(cxt);
+        skipWhitespace(cxt);
+        gen.if(names_1.default.jsonPart, () => {
+            gen.assign((0, codegen_1._) `${parseName}.position`, names_1.default.jsonPos);
+            gen.return(names_1.default.data);
+        });
+        gen.if((0, codegen_1._) `${names_1.default.jsonPos} === ${names_1.default.jsonLen}`, () => gen.return(names_1.default.data));
+        jsonSyntaxError(cxt);
+    });
+}
+function parseCode(cxt) {
+    let form;
+    for (const key of types_1.jtdForms) {
+        if (key in cxt.schema) {
+            form = key;
+            break;
+        }
+    }
+    if (form)
+        parseNullable(cxt, genParse[form]);
+    else
+        parseEmpty(cxt);
+}
+const parseBoolean = parseBooleanToken(true, parseBooleanToken(false, jsonSyntaxError));
+function parseNullable(cxt, parseForm) {
+    const { gen, schema, data } = cxt;
+    if (!schema.nullable)
+        return parseForm(cxt);
+    tryParseToken(cxt, "null", parseForm, () => gen.assign(data, null));
+}
+function parseElements(cxt) {
+    const { gen, schema, data } = cxt;
+    parseToken(cxt, "[");
+    const ix = gen.let("i", 0);
+    gen.assign(data, (0, codegen_1._) `[]`);
+    parseItems(cxt, "]", () => {
+        const el = gen.let("el");
+        parseCode({ ...cxt, schema: schema.elements, data: el });
+        gen.assign((0, codegen_1._) `${data}[${ix}++]`, el);
+    });
+}
+function parseValues(cxt) {
+    const { gen, schema, data } = cxt;
+    parseToken(cxt, "{");
+    gen.assign(data, (0, codegen_1._) `{}`);
+    parseItems(cxt, "}", () => parseKeyValue(cxt, schema.values));
+}
+function parseItems(cxt, endToken, block) {
+    tryParseItems(cxt, endToken, block);
+    parseToken(cxt, endToken);
+}
+function tryParseItems(cxt, endToken, block) {
+    const { gen } = cxt;
+    gen.for((0, codegen_1._) `;${names_1.default.jsonPos}<${names_1.default.jsonLen} && ${jsonSlice(1)}!==${endToken};`, () => {
+        block();
+        tryParseToken(cxt, ",", () => gen.break(), hasItem);
+    });
+    function hasItem() {
+        tryParseToken(cxt, endToken, () => { }, jsonSyntaxError);
+    }
+}
+function parseKeyValue(cxt, schema) {
+    const { gen } = cxt;
+    const key = gen.let("key");
+    parseString({ ...cxt, data: key });
+    parseToken(cxt, ":");
+    parsePropertyValue(cxt, key, schema);
+}
+function parseDiscriminator(cxt) {
+    const { gen, data, schema } = cxt;
+    const { discriminator, mapping } = schema;
+    parseToken(cxt, "{");
+    gen.assign(data, (0, codegen_1._) `{}`);
+    const startPos = gen.const("pos", names_1.default.jsonPos);
+    const value = gen.let("value");
+    const tag = gen.let("tag");
+    tryParseItems(cxt, "}", () => {
+        const key = gen.let("key");
+        parseString({ ...cxt, data: key });
+        parseToken(cxt, ":");
+        gen.if((0, codegen_1._) `${key} === ${discriminator}`, () => {
+            parseString({ ...cxt, data: tag });
+            gen.assign((0, codegen_1._) `${data}[${key}]`, tag);
+            gen.break();
+        }, () => parseEmpty({ ...cxt, data: value }) // can be discarded/skipped
+        );
+    });
+    gen.assign(names_1.default.jsonPos, startPos);
+    gen.if((0, codegen_1._) `${tag} === undefined`);
+    parsingError(cxt, (0, codegen_1.str) `discriminator tag not found`);
+    for (const tagValue in mapping) {
+        gen.elseIf((0, codegen_1._) `${tag} === ${tagValue}`);
+        parseSchemaProperties({ ...cxt, schema: mapping[tagValue] }, discriminator);
+    }
+    gen.else();
+    parsingError(cxt, (0, codegen_1.str) `discriminator value not in schema`);
+    gen.endIf();
+}
+function parseProperties(cxt) {
+    const { gen, data } = cxt;
+    parseToken(cxt, "{");
+    gen.assign(data, (0, codegen_1._) `{}`);
+    parseSchemaProperties(cxt);
+}
+function parseSchemaProperties(cxt, discriminator) {
+    const { gen, schema, data } = cxt;
+    const { properties, optionalProperties, additionalProperties } = schema;
+    parseItems(cxt, "}", () => {
+        const key = gen.let("key");
+        parseString({ ...cxt, data: key });
+        parseToken(cxt, ":");
+        gen.if(false);
+        parseDefinedProperty(cxt, key, properties);
+        parseDefinedProperty(cxt, key, optionalProperties);
+        if (discriminator) {
+            gen.elseIf((0, codegen_1._) `${key} === ${discriminator}`);
+            const tag = gen.let("tag");
+            parseString({ ...cxt, data: tag }); // can be discarded, it is already assigned
+        }
+        gen.else();
+        if (additionalProperties) {
+            parseEmpty({ ...cxt, data: (0, codegen_1._) `${data}[${key}]` });
+        }
+        else {
+            parsingError(cxt, (0, codegen_1.str) `property ${key} not allowed`);
+        }
+        gen.endIf();
+    });
+    if (properties) {
+        const hasProp = (0, code_1.hasPropFunc)(gen);
+        const allProps = (0, codegen_1.and)(...Object.keys(properties).map((p) => (0, codegen_1._) `${hasProp}.call(${data}, ${p})`));
+        gen.if((0, codegen_1.not)(allProps), () => parsingError(cxt, (0, codegen_1.str) `missing required properties`));
+    }
+}
+function parseDefinedProperty(cxt, key, schemas = {}) {
+    const { gen } = cxt;
+    for (const prop in schemas) {
+        gen.elseIf((0, codegen_1._) `${key} === ${prop}`);
+        parsePropertyValue(cxt, key, schemas[prop]);
+    }
+}
+function parsePropertyValue(cxt, key, schema) {
+    parseCode({ ...cxt, schema, data: (0, codegen_1._) `${cxt.data}[${key}]` });
+}
+function parseType(cxt) {
+    const { gen, schema, data, self } = cxt;
+    switch (schema.type) {
+        case "boolean":
+            parseBoolean(cxt);
+            break;
+        case "string":
+            parseString(cxt);
+            break;
+        case "timestamp": {
+            parseString(cxt);
+            const vts = (0, util_1.useFunc)(gen, timestamp_1.default);
+            const { allowDate, parseDate } = self.opts;
+            const notValid = allowDate ? (0, codegen_1._) `!${vts}(${data}, true)` : (0, codegen_1._) `!${vts}(${data})`;
+            const fail = parseDate
+                ? (0, codegen_1.or)(notValid, (0, codegen_1._) `(${data} = new Date(${data}), false)`, (0, codegen_1._) `isNaN(${data}.valueOf())`)
+                : notValid;
+            gen.if(fail, () => parsingError(cxt, (0, codegen_1.str) `invalid timestamp`));
+            break;
+        }
+        case "float32":
+        case "float64":
+            parseNumber(cxt);
+            break;
+        default: {
+            const t = schema.type;
+            if (!self.opts.int32range && (t === "int32" || t === "uint32")) {
+                parseNumber(cxt, 16); // 2 ** 53 - max safe integer
+                if (t === "uint32") {
+                    gen.if((0, codegen_1._) `${data} < 0`, () => parsingError(cxt, (0, codegen_1.str) `integer out of range`));
+                }
+            }
+            else {
+                const [min, max, maxDigits] = type_1.intRange[t];
+                parseNumber(cxt, maxDigits);
+                gen.if((0, codegen_1._) `${data} < ${min} || ${data} > ${max}`, () => parsingError(cxt, (0, codegen_1.str) `integer out of range`));
+            }
+        }
+    }
+}
+function parseString(cxt) {
+    parseToken(cxt, '"');
+    parseWith(cxt, parseJson_1.parseJsonString);
+}
+function parseEnum(cxt) {
+    const { gen, data, schema } = cxt;
+    const enumSch = schema.enum;
+    parseToken(cxt, '"');
+    // TODO loopEnum
+    gen.if(false);
+    for (const value of enumSch) {
+        const valueStr = JSON.stringify(value).slice(1); // remove starting quote
+        gen.elseIf((0, codegen_1._) `${jsonSlice(valueStr.length)} === ${valueStr}`);
+        gen.assign(data, (0, codegen_1.str) `${value}`);
+        gen.add(names_1.default.jsonPos, valueStr.length);
+    }
+    gen.else();
+    jsonSyntaxError(cxt);
+    gen.endIf();
+}
+function parseNumber(cxt, maxDigits) {
+    const { gen } = cxt;
+    skipWhitespace(cxt);
+    gen.if((0, codegen_1._) `"-0123456789".indexOf(${jsonSlice(1)}) < 0`, () => jsonSyntaxError(cxt), () => parseWith(cxt, parseJson_1.parseJsonNumber, maxDigits));
+}
+function parseBooleanToken(bool, fail) {
+    return (cxt) => {
+        const { gen, data } = cxt;
+        tryParseToken(cxt, `${bool}`, () => fail(cxt), () => gen.assign(data, bool));
+    };
+}
+function parseRef(cxt) {
+    const { gen, self, definitions, schema, schemaEnv } = cxt;
+    const { ref } = schema;
+    const refSchema = definitions[ref];
+    if (!refSchema)
+        throw new ref_error_1.default(self.opts.uriResolver, "", ref, `No definition ${ref}`);
+    if (!(0, ref_1.hasRef)(refSchema))
+        return parseCode({ ...cxt, schema: refSchema });
+    const { root } = schemaEnv;
+    const sch = compileParser.call(self, new __1.SchemaEnv({ schema: refSchema, root }), definitions);
+    partialParse(cxt, getParser(gen, sch), true);
+}
+function getParser(gen, sch) {
+    return sch.parse
+        ? gen.scopeValue("parse", { ref: sch.parse })
+        : (0, codegen_1._) `${gen.scopeValue("wrapper", { ref: sch })}.parse`;
+}
+function parseEmpty(cxt) {
+    parseWith(cxt, parseJson_1.parseJson);
+}
+function parseWith(cxt, parseFunc, args) {
+    partialParse(cxt, (0, util_1.useFunc)(cxt.gen, parseFunc), args);
+}
+function partialParse(cxt, parseFunc, args) {
+    const { gen, data } = cxt;
+    gen.assign(data, (0, codegen_1._) `${parseFunc}(${names_1.default.json}, ${names_1.default.jsonPos}${args ? (0, codegen_1._) `, ${args}` : codegen_1.nil})`);
+    gen.assign(names_1.default.jsonPos, (0, codegen_1._) `${parseFunc}.position`);
+    gen.if((0, codegen_1._) `${data} === undefined`, () => parsingError(cxt, (0, codegen_1._) `${parseFunc}.message`));
+}
+function parseToken(cxt, tok) {
+    tryParseToken(cxt, tok, jsonSyntaxError);
+}
+function tryParseToken(cxt, tok, fail, success) {
+    const { gen } = cxt;
+    const n = tok.length;
+    skipWhitespace(cxt);
+    gen.if((0, codegen_1._) `${jsonSlice(n)} === ${tok}`, () => {
+        gen.add(names_1.default.jsonPos, n);
+        success === null || success === void 0 ? void 0 : success(cxt);
+    }, () => fail(cxt));
+}
+function skipWhitespace({ gen, char: c }) {
+    gen.code((0, codegen_1._) `while((${c}=${names_1.default.json}[${names_1.default.jsonPos}],${c}===" "||${c}==="\\n"||${c}==="\\r"||${c}==="\\t"))${names_1.default.jsonPos}++;`);
+}
+function jsonSlice(len) {
+    return len === 1
+        ? (0, codegen_1._) `${names_1.default.json}[${names_1.default.jsonPos}]`
+        : (0, codegen_1._) `${names_1.default.json}.slice(${names_1.default.jsonPos}, ${names_1.default.jsonPos}+${len})`;
+}
+function jsonSyntaxError(cxt) {
+    parsingError(cxt, (0, codegen_1._) `"unexpected token " + ${names_1.default.json}[${names_1.default.jsonPos}]`);
+}
+function parsingError({ gen, parseName }, msg) {
+    gen.assign((0, codegen_1._) `${parseName}.message`, msg);
+    gen.assign((0, codegen_1._) `${parseName}.position`, names_1.default.jsonPos);
+    gen.return(undef);
+}
+//# sourceMappingURL=parse.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/serialize.d.ts

@@ -0,0 +1,4 @@
+import type Ajv from "../../core";
+import { SchemaObjectMap } from "./types";
+import { SchemaEnv } from "..";
+export default function compileSerializer(this: Ajv, sch: SchemaEnv, definitions: SchemaObjectMap): SchemaEnv;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/serialize.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const __1 = require("..");
+const codegen_1 = require("../codegen");
+const ref_error_1 = require("../ref_error");
+const names_1 = require("../names");
+const code_1 = require("../../vocabularies/code");
+const ref_1 = require("../../vocabularies/jtd/ref");
+const util_1 = require("../util");
+const quote_1 = require("../../runtime/quote");
+const genSerialize = {
+    elements: serializeElements,
+    values: serializeValues,
+    discriminator: serializeDiscriminator,
+    properties: serializeProperties,
+    optionalProperties: serializeProperties,
+    enum: serializeString,
+    type: serializeType,
+    ref: serializeRef,
+};
+function compileSerializer(sch, definitions) {
+    const _sch = __1.getCompilingSchema.call(this, sch);
+    if (_sch)
+        return _sch;
+    const { es5, lines } = this.opts.code;
+    const { ownProperties } = this.opts;
+    const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
+    const serializeName = gen.scopeName("serialize");
+    const cxt = {
+        self: this,
+        gen,
+        schema: sch.schema,
+        schemaEnv: sch,
+        definitions,
+        data: names_1.default.data,
+    };
+    let sourceCode;
+    try {
+        this._compilations.add(sch);
+        sch.serializeName = serializeName;
+        gen.func(serializeName, names_1.default.data, false, () => {
+            gen.let(names_1.default.json, (0, codegen_1.str) ``);
+            serializeCode(cxt);
+            gen.return(names_1.default.json);
+        });
+        gen.optimize(this.opts.code.optimize);
+        const serializeFuncCode = gen.toString();
+        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${serializeFuncCode}`;
+        const makeSerialize = new Function(`${names_1.default.scope}`, sourceCode);
+        const serialize = makeSerialize(this.scope.get());
+        this.scope.value(serializeName, { ref: serialize });
+        sch.serialize = serialize;
+    }
+    catch (e) {
+        if (sourceCode)
+            this.logger.error("Error compiling serializer, function code:", sourceCode);
+        delete sch.serialize;
+        delete sch.serializeName;
+        throw e;
+    }
+    finally {
+        this._compilations.delete(sch);
+    }
+    return sch;
+}
+exports.default = compileSerializer;
+function serializeCode(cxt) {
+    let form;
+    for (const key of types_1.jtdForms) {
+        if (key in cxt.schema) {
+            form = key;
+            break;
+        }
+    }
+    serializeNullable(cxt, form ? genSerialize[form] : serializeEmpty);
+}
+function serializeNullable(cxt, serializeForm) {
+    const { gen, schema, data } = cxt;
+    if (!schema.nullable)
+        return serializeForm(cxt);
+    gen.if((0, codegen_1._) `${data} === undefined || ${data} === null`, () => gen.add(names_1.default.json, (0, codegen_1._) `"null"`), () => serializeForm(cxt));
+}
+function serializeElements(cxt) {
+    const { gen, schema, data } = cxt;
+    gen.add(names_1.default.json, (0, codegen_1.str) `[`);
+    const first = gen.let("first", true);
+    gen.forOf("el", data, (el) => {
+        addComma(cxt, first);
+        serializeCode({ ...cxt, schema: schema.elements, data: el });
+    });
+    gen.add(names_1.default.json, (0, codegen_1.str) `]`);
+}
+function serializeValues(cxt) {
+    const { gen, schema, data } = cxt;
+    gen.add(names_1.default.json, (0, codegen_1.str) `{`);
+    const first = gen.let("first", true);
+    gen.forIn("key", data, (key) => serializeKeyValue(cxt, key, schema.values, first));
+    gen.add(names_1.default.json, (0, codegen_1.str) `}`);
+}
+function serializeKeyValue(cxt, key, schema, first) {
+    const { gen, data } = cxt;
+    addComma(cxt, first);
+    serializeString({ ...cxt, data: key });
+    gen.add(names_1.default.json, (0, codegen_1.str) `:`);
+    const value = gen.const("value", (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(key)}`);
+    serializeCode({ ...cxt, schema, data: value });
+}
+function serializeDiscriminator(cxt) {
+    const { gen, schema, data } = cxt;
+    const { discriminator } = schema;
+    gen.add(names_1.default.json, (0, codegen_1.str) `{${JSON.stringify(discriminator)}:`);
+    const tag = gen.const("tag", (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(discriminator)}`);
+    serializeString({ ...cxt, data: tag });
+    gen.if(false);
+    for (const tagValue in schema.mapping) {
+        gen.elseIf((0, codegen_1._) `${tag} === ${tagValue}`);
+        const sch = schema.mapping[tagValue];
+        serializeSchemaProperties({ ...cxt, schema: sch }, discriminator);
+    }
+    gen.endIf();
+    gen.add(names_1.default.json, (0, codegen_1.str) `}`);
+}
+function serializeProperties(cxt) {
+    const { gen } = cxt;
+    gen.add(names_1.default.json, (0, codegen_1.str) `{`);
+    serializeSchemaProperties(cxt);
+    gen.add(names_1.default.json, (0, codegen_1.str) `}`);
+}
+function serializeSchemaProperties(cxt, discriminator) {
+    const { gen, schema, data } = cxt;
+    const { properties, optionalProperties } = schema;
+    const props = keys(properties);
+    const optProps = keys(optionalProperties);
+    const allProps = allProperties(props.concat(optProps));
+    let first = !discriminator;
+    let firstProp;
+    for (const key of props) {
+        if (first)
+            first = false;
+        else
+            gen.add(names_1.default.json, (0, codegen_1.str) `,`);
+        serializeProperty(key, properties[key], keyValue(key));
+    }
+    if (first)
+        firstProp = gen.let("first", true);
+    for (const key of optProps) {
+        const value = keyValue(key);
+        gen.if((0, codegen_1.and)((0, codegen_1._) `${value} !== undefined`, (0, code_1.isOwnProperty)(gen, data, key)), () => {
+            addComma(cxt, firstProp);
+            serializeProperty(key, optionalProperties[key], value);
+        });
+    }
+    if (schema.additionalProperties) {
+        gen.forIn("key", data, (key) => gen.if(isAdditional(key, allProps), () => serializeKeyValue(cxt, key, {}, firstProp)));
+    }
+    function keys(ps) {
+        return ps ? Object.keys(ps) : [];
+    }
+    function allProperties(ps) {
+        if (discriminator)
+            ps.push(discriminator);
+        if (new Set(ps).size !== ps.length) {
+            throw new Error("JTD: properties/optionalProperties/disciminator overlap");
+        }
+        return ps;
+    }
+    function keyValue(key) {
+        return gen.const("value", (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(key)}`);
+    }
+    function serializeProperty(key, propSchema, value) {
+        gen.add(names_1.default.json, (0, codegen_1.str) `${JSON.stringify(key)}:`);
+        serializeCode({ ...cxt, schema: propSchema, data: value });
+    }
+    function isAdditional(key, ps) {
+        return ps.length ? (0, codegen_1.and)(...ps.map((p) => (0, codegen_1._) `${key} !== ${p}`)) : true;
+    }
+}
+function serializeType(cxt) {
+    const { gen, schema, data } = cxt;
+    switch (schema.type) {
+        case "boolean":
+            gen.add(names_1.default.json, (0, codegen_1._) `${data} ? "true" : "false"`);
+            break;
+        case "string":
+            serializeString(cxt);
+            break;
+        case "timestamp":
+            gen.if((0, codegen_1._) `${data} instanceof Date`, () => gen.add(names_1.default.json, (0, codegen_1._) `'"' + ${data}.toISOString() + '"'`), () => serializeString(cxt));
+            break;
+        default:
+            serializeNumber(cxt);
+    }
+}
+function serializeString({ gen, data }) {
+    gen.add(names_1.default.json, (0, codegen_1._) `${(0, util_1.useFunc)(gen, quote_1.default)}(${data})`);
+}
+function serializeNumber({ gen, data }) {
+    gen.add(names_1.default.json, (0, codegen_1._) `"" + ${data}`);
+}
+function serializeRef(cxt) {
+    const { gen, self, data, definitions, schema, schemaEnv } = cxt;
+    const { ref } = schema;
+    const refSchema = definitions[ref];
+    if (!refSchema)
+        throw new ref_error_1.default(self.opts.uriResolver, "", ref, `No definition ${ref}`);
+    if (!(0, ref_1.hasRef)(refSchema))
+        return serializeCode({ ...cxt, schema: refSchema });
+    const { root } = schemaEnv;
+    const sch = compileSerializer.call(self, new __1.SchemaEnv({ schema: refSchema, root }), definitions);
+    gen.add(names_1.default.json, (0, codegen_1._) `${getSerialize(gen, sch)}(${data})`);
+}
+function getSerialize(gen, sch) {
+    return sch.serialize
+        ? gen.scopeValue("serialize", { ref: sch.serialize })
+        : (0, codegen_1._) `${gen.scopeValue("wrapper", { ref: sch })}.serialize`;
+}
+function serializeEmpty({ gen, data }) {
+    gen.add(names_1.default.json, (0, codegen_1._) `JSON.stringify(${data})`);
+}
+function addComma({ gen }, first) {
+    if (first) {
+        gen.if(first, () => gen.assign(first, false), () => gen.add(names_1.default.json, (0, codegen_1.str) `,`));
+    }
+    else {
+        gen.add(names_1.default.json, (0, codegen_1.str) `,`);
+    }
+}
+//# sourceMappingURL=serialize.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/types.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaObject } from "../../types";
+export type SchemaObjectMap = {
+    [Ref in string]?: SchemaObject;
+};
+export declare const jtdForms: readonly ["elements", "values", "discriminator", "properties", "optionalProperties", "enum", "type", "ref"];
+export type JTDForm = (typeof jtdForms)[number];

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jtdForms = void 0;
+exports.jtdForms = [
+    "elements",
+    "values",
+    "discriminator",
+    "properties",
+    "optionalProperties",
+    "enum",
+    "type",
+    "ref",
+];
+//# sourceMappingURL=types.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/jtd/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../lib/compile/jtd/types.ts"],"names":[],"mappings":";;;AAIa,QAAA,QAAQ,GAAG;IACtB,UAAU;IACV,QAAQ;IACR,eAAe;IACf,YAAY;IACZ,oBAAoB;IACpB,MAAM;IACN,MAAM;IACN,KAAK;CACG,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/names.d.ts

@@ -0,0 +1,20 @@
+import { Name } from "./codegen";
+declare const names: {
+    data: Name;
+    valCxt: Name;
+    instancePath: Name;
+    parentData: Name;
+    parentDataProperty: Name;
+    rootData: Name;
+    dynamicAnchors: Name;
+    vErrors: Name;
+    errors: Name;
+    this: Name;
+    self: Name;
+    scope: Name;
+    json: Name;
+    jsonPos: Name;
+    jsonLen: Name;
+    jsonPart: Name;
+};
+export default names;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/names.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("./codegen");
+const names = {
+    // validation function arguments
+    data: new codegen_1.Name("data"), // data passed to validation function
+    // args passed from referencing schema
+    valCxt: new codegen_1.Name("valCxt"), // validation/data context - should not be used directly, it is destructured to the names below
+    instancePath: new codegen_1.Name("instancePath"),
+    parentData: new codegen_1.Name("parentData"),
+    parentDataProperty: new codegen_1.Name("parentDataProperty"),
+    rootData: new codegen_1.Name("rootData"), // root data - same as the data passed to the first/top validation function
+    dynamicAnchors: new codegen_1.Name("dynamicAnchors"), // used to support recursiveRef and dynamicRef
+    // function scoped variables
+    vErrors: new codegen_1.Name("vErrors"), // null or array of validation errors
+    errors: new codegen_1.Name("errors"), // counter of validation errors
+    this: new codegen_1.Name("this"),
+    // "globals"
+    self: new codegen_1.Name("self"),
+    scope: new codegen_1.Name("scope"),
+    // JTD serialize/parse name for JSON string and position
+    json: new codegen_1.Name("json"),
+    jsonPos: new codegen_1.Name("jsonPos"),
+    jsonLen: new codegen_1.Name("jsonLen"),
+    jsonPart: new codegen_1.Name("jsonPart"),
+};
+exports.default = names;
+//# sourceMappingURL=names.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.js","sourceRoot":"","sources":["../../lib/compile/names.ts"],"names":[],"mappings":";;AAAA,uCAA8B;AAE9B,MAAM,KAAK,GAAG;IACZ,gCAAgC;IAChC,IAAI,EAAE,IAAI,cAAI,CAAC,MAAM,CAAC,EAAE,qCAAqC;IAC7D,sCAAsC;IACtC,MAAM,EAAE,IAAI,cAAI,CAAC,QAAQ,CAAC,EAAE,+FAA+F;IAC3H,YAAY,EAAE,IAAI,cAAI,CAAC,cAAc,CAAC;IACtC,UAAU,EAAE,IAAI,cAAI,CAAC,YAAY,CAAC;IAClC,kBAAkB,EAAE,IAAI,cAAI,CAAC,oBAAoB,CAAC;IAClD,QAAQ,EAAE,IAAI,cAAI,CAAC,UAAU,CAAC,EAAE,2EAA2E;IAC3G,cAAc,EAAE,IAAI,cAAI,CAAC,gBAAgB,CAAC,EAAE,8CAA8C;IAC1F,4BAA4B;IAC5B,OAAO,EAAE,IAAI,cAAI,CAAC,SAAS,CAAC,EAAE,qCAAqC;IACnE,MAAM,EAAE,IAAI,cAAI,CAAC,QAAQ,CAAC,EAAE,+BAA+B;IAC3D,IAAI,EAAE,IAAI,cAAI,CAAC,MAAM,CAAC;IACtB,YAAY;IACZ,IAAI,EAAE,IAAI,cAAI,CAAC,MAAM,CAAC;IACtB,KAAK,EAAE,IAAI,cAAI,CAAC,OAAO,CAAC;IACxB,wDAAwD;IACxD,IAAI,EAAE,IAAI,cAAI,CAAC,MAAM,CAAC;IACtB,OAAO,EAAE,IAAI,cAAI,CAAC,SAAS,CAAC;IAC5B,OAAO,EAAE,IAAI,cAAI,CAAC,SAAS,CAAC;IAC5B,QAAQ,EAAE,IAAI,cAAI,CAAC,UAAU,CAAC;CAC/B,CAAA;AAED,kBAAe,KAAK,CAAA"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/ref_error.d.ts

@@ -0,0 +1,6 @@
+import type { UriResolver } from "../types";
+export default class MissingRefError extends Error {
+    readonly missingRef: string;
+    readonly missingSchema: string;
+    constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string);
+}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/ref_error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolve_1 = require("./resolve");
+class MissingRefError extends Error {
+    constructor(resolver, baseId, ref, msg) {
+        super(msg || `can't resolve reference ${ref} from id ${baseId}`);
+        this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
+        this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
+    }
+}
+exports.default = MissingRefError;
+//# sourceMappingURL=ref_error.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/ref_error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref_error.js","sourceRoot":"","sources":["../../lib/compile/ref_error.ts"],"names":[],"mappings":";;AAAA,uCAA8D;AAG9D,MAAqB,eAAgB,SAAQ,KAAK;IAIhD,YAAY,QAAqB,EAAE,MAAc,EAAE,GAAW,EAAE,GAAY;QAC1E,KAAK,CAAC,GAAG,IAAI,2BAA2B,GAAG,YAAY,MAAM,EAAE,CAAC,CAAA;QAChE,IAAI,CAAC,UAAU,GAAG,IAAA,oBAAU,EAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;QACnD,IAAI,CAAC,aAAa,GAAG,IAAA,qBAAW,EAAC,IAAA,qBAAW,EAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAA;IAC1E,CAAC;CACF;AATD,kCASC"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/resolve.d.ts

@@ -0,0 +1,12 @@
+import type { AnySchema, AnySchemaObject, UriResolver } from "../types";
+import type Ajv from "../ajv";
+import type { URIComponent } from "fast-uri";
+export type LocalRefs = {
+    [Ref in string]?: AnySchemaObject;
+};
+export declare function inlineRef(schema: AnySchema, limit?: boolean | number): boolean;
+export declare function getFullPath(resolver: UriResolver, id?: string, normalize?: boolean): string;
+export declare function _getFullPath(resolver: UriResolver, p: URIComponent): string;
+export declare function normalizeId(id: string | undefined): string;
+export declare function resolveUrl(resolver: UriResolver, baseId: string, id: string): string;
+export declare function getSchemaRefs(this: Ajv, schema: AnySchema, baseId: string): LocalRefs;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/resolve.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
+const util_1 = require("./util");
+const equal = require("fast-deep-equal");
+const traverse = require("json-schema-traverse");
+// TODO refactor to use keyword definitions
+const SIMPLE_INLINED = new Set([
+    "type",
+    "format",
+    "pattern",
+    "maxLength",
+    "minLength",
+    "maxProperties",
+    "minProperties",
+    "maxItems",
+    "minItems",
+    "maximum",
+    "minimum",
+    "uniqueItems",
+    "multipleOf",
+    "required",
+    "enum",
+    "const",
+]);
+function inlineRef(schema, limit = true) {
+    if (typeof schema == "boolean")
+        return true;
+    if (limit === true)
+        return !hasRef(schema);
+    if (!limit)
+        return false;
+    return countKeys(schema) <= limit;
+}
+exports.inlineRef = inlineRef;
+const REF_KEYWORDS = new Set([
+    "$ref",
+    "$recursiveRef",
+    "$recursiveAnchor",
+    "$dynamicRef",
+    "$dynamicAnchor",
+]);
+function hasRef(schema) {
+    for (const key in schema) {
+        if (REF_KEYWORDS.has(key))
+            return true;
+        const sch = schema[key];
+        if (Array.isArray(sch) && sch.some(hasRef))
+            return true;
+        if (typeof sch == "object" && hasRef(sch))
+            return true;
+    }
+    return false;
+}
+function countKeys(schema) {
+    let count = 0;
+    for (const key in schema) {
+        if (key === "$ref")
+            return Infinity;
+        count++;
+        if (SIMPLE_INLINED.has(key))
+            continue;
+        if (typeof schema[key] == "object") {
+            (0, util_1.eachItem)(schema[key], (sch) => (count += countKeys(sch)));
+        }
+        if (count === Infinity)
+            return Infinity;
+    }
+    return count;
+}
+function getFullPath(resolver, id = "", normalize) {
+    if (normalize !== false)
+        id = normalizeId(id);
+    const p = resolver.parse(id);
+    return _getFullPath(resolver, p);
+}
+exports.getFullPath = getFullPath;
+function _getFullPath(resolver, p) {
+    const serialized = resolver.serialize(p);
+    return serialized.split("#")[0] + "#";
+}
+exports._getFullPath = _getFullPath;
+const TRAILING_SLASH_HASH = /#\/?$/;
+function normalizeId(id) {
+    return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
+}
+exports.normalizeId = normalizeId;
+function resolveUrl(resolver, baseId, id) {
+    id = normalizeId(id);
+    return resolver.resolve(baseId, id);
+}
+exports.resolveUrl = resolveUrl;
+const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
+function getSchemaRefs(schema, baseId) {
+    if (typeof schema == "boolean")
+        return {};
+    const { schemaId, uriResolver } = this.opts;
+    const schId = normalizeId(schema[schemaId] || baseId);
+    const baseIds = { "": schId };
+    const pathPrefix = getFullPath(uriResolver, schId, false);
+    const localRefs = {};
+    const schemaRefs = new Set();
+    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+        if (parentJsonPtr === undefined)
+            return;
+        const fullPath = pathPrefix + jsonPtr;
+        let innerBaseId = baseIds[parentJsonPtr];
+        if (typeof sch[schemaId] == "string")
+            innerBaseId = addRef.call(this, sch[schemaId]);
+        addAnchor.call(this, sch.$anchor);
+        addAnchor.call(this, sch.$dynamicAnchor);
+        baseIds[jsonPtr] = innerBaseId;
+        function addRef(ref) {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            const _resolve = this.opts.uriResolver.resolve;
+            ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
+            if (schemaRefs.has(ref))
+                throw ambiguos(ref);
+            schemaRefs.add(ref);
+            let schOrRef = this.refs[ref];
+            if (typeof schOrRef == "string")
+                schOrRef = this.refs[schOrRef];
+            if (typeof schOrRef == "object") {
+                checkAmbiguosRef(sch, schOrRef.schema, ref);
+            }
+            else if (ref !== normalizeId(fullPath)) {
+                if (ref[0] === "#") {
+                    checkAmbiguosRef(sch, localRefs[ref], ref);
+                    localRefs[ref] = sch;
+                }
+                else {
+                    this.refs[ref] = fullPath;
+                }
+            }
+            return ref;
+        }
+        function addAnchor(anchor) {
+            if (typeof anchor == "string") {
+                if (!ANCHOR.test(anchor))
+                    throw new Error(`invalid anchor "${anchor}"`);
+                addRef.call(this, `#${anchor}`);
+            }
+        }
+    });
+    return localRefs;
+    function checkAmbiguosRef(sch1, sch2, ref) {
+        if (sch2 !== undefined && !equal(sch1, sch2))
+            throw ambiguos(ref);
+    }
+    function ambiguos(ref) {
+        return new Error(`reference "${ref}" resolves to more than one schema`);
+    }
+}
+exports.getSchemaRefs = getSchemaRefs;
+//# sourceMappingURL=resolve.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../lib/compile/resolve.ts"],"names":[],"mappings":";;;AAGA,iCAA+B;AAC/B,yCAAwC;AACxC,iDAAgD;AAKhD,2CAA2C;AAC3C,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;IAC7B,MAAM;IACN,QAAQ;IACR,SAAS;IACT,WAAW;IACX,WAAW;IACX,eAAe;IACf,eAAe;IACf,UAAU;IACV,UAAU;IACV,SAAS;IACT,SAAS;IACT,aAAa;IACb,YAAY;IACZ,UAAU;IACV,MAAM;IACN,OAAO;CACR,CAAC,CAAA;AAEF,SAAgB,SAAS,CAAC,MAAiB,EAAE,QAA0B,IAAI;IACzE,IAAI,OAAO,MAAM,IAAI,SAAS;QAAE,OAAO,IAAI,CAAA;IAC3C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAA;IACxB,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,CAAA;AACnC,CAAC;AALD,8BAKC;AAED,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC;IAC3B,MAAM;IACN,eAAe;IACf,kBAAkB;IAClB,aAAa;IACb,gBAAgB;CACjB,CAAC,CAAA;AAEF,SAAS,MAAM,CAAC,MAAuB;IACrC,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAA;QACtC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;QACvB,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAA;QACvD,IAAI,OAAO,GAAG,IAAI,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAA;IACxD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,SAAS,CAAC,MAAuB;IACxC,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,IAAI,GAAG,KAAK,MAAM;YAAE,OAAO,QAAQ,CAAA;QACnC,KAAK,EAAE,CAAA;QACP,IAAI,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAQ;QACrC,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,EAAE,CAAC;YACnC,IAAA,eAAQ,EAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QAC3D,CAAC;QACD,IAAI,KAAK,KAAK,QAAQ;YAAE,OAAO,QAAQ,CAAA;IACzC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAgB,WAAW,CAAC,QAAqB,EAAE,EAAE,GAAG,EAAE,EAAE,SAAmB;IAC7E,IAAI,SAAS,KAAK,KAAK;QAAE,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IAC7C,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAC5B,OAAO,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;AAClC,CAAC;AAJD,kCAIC;AAED,SAAgB,YAAY,CAAC,QAAqB,EAAE,CAAe;IACjE,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IACxC,OAAO,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAA;AACvC,CAAC;AAHD,oCAGC;AAED,MAAM,mBAAmB,GAAG,OAAO,CAAA;AACnC,SAAgB,WAAW,CAAC,EAAsB;IAChD,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AACtD,CAAC;AAFD,kCAEC;AAED,SAAgB,UAAU,CAAC,QAAqB,EAAE,MAAc,EAAE,EAAU;IAC1E,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IACpB,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;AACrC,CAAC;AAHD,gCAGC;AAED,MAAM,MAAM,GAAG,uBAAuB,CAAA;AAEtC,SAAgB,aAAa,CAAY,MAAiB,EAAE,MAAc;IACxE,IAAI,OAAO,MAAM,IAAI,SAAS;QAAE,OAAO,EAAE,CAAA;IACzC,MAAM,EAAC,QAAQ,EAAE,WAAW,EAAC,GAAG,IAAI,CAAC,IAAI,CAAA;IACzC,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,CAAA;IACrD,MAAM,OAAO,GAAmC,EAAC,EAAE,EAAE,KAAK,EAAC,CAAA;IAC3D,MAAM,UAAU,GAAG,WAAW,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;IACzD,MAAM,SAAS,GAAc,EAAE,CAAA;IAC/B,MAAM,UAAU,GAAgB,IAAI,GAAG,EAAE,CAAA;IAEzC,QAAQ,CAAC,MAAM,EAAE,EAAC,OAAO,EAAE,IAAI,EAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,aAAa,EAAE,EAAE;QACnE,IAAI,aAAa,KAAK,SAAS;YAAE,OAAM;QACvC,MAAM,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAA;QACrC,IAAI,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;QACxC,IAAI,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,QAAQ;YAAE,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAA;QACpF,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;QACjC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,cAAc,CAAC,CAAA;QACxC,OAAO,CAAC,OAAO,CAAC,GAAG,WAAW,CAAA;QAE9B,SAAS,MAAM,CAAY,GAAW;YACpC,6DAA6D;YAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAA;YAC9C,GAAG,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;YACjE,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,MAAM,QAAQ,CAAC,GAAG,CAAC,CAAA;YAC5C,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YACnB,IAAI,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC7B,IAAI,OAAO,QAAQ,IAAI,QAAQ;gBAAE,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC/D,IAAI,OAAO,QAAQ,IAAI,QAAQ,EAAE,CAAC;gBAChC,gBAAgB,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;YAC7C,CAAC;iBAAM,IAAI,GAAG,KAAK,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACzC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;oBACnB,gBAAgB,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;oBAC1C,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;gBACtB,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAA;gBAC3B,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAA;QACZ,CAAC;QAED,SAAS,SAAS,CAAY,MAAe;YAC3C,IAAI,OAAO,MAAM,IAAI,QAAQ,EAAE,CAAC;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,mBAAmB,MAAM,GAAG,CAAC,CAAA;gBACvE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,MAAM,EAAE,CAAC,CAAA;YACjC,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,SAAS,CAAA;IAEhB,SAAS,gBAAgB,CAAC,IAAe,EAAE,IAA2B,EAAE,GAAW;QACjF,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;YAAE,MAAM,QAAQ,CAAC,GAAG,CAAC,CAAA;IACnE,CAAC;IAED,SAAS,QAAQ,CAAC,GAAW;QAC3B,OAAO,IAAI,KAAK,CAAC,cAAc,GAAG,oCAAoC,CAAC,CAAA;IACzE,CAAC;AACH,CAAC;AAxDD,sCAwDC"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/rules.d.ts

@@ -0,0 +1,28 @@
+import type { AddedKeywordDefinition } from "../types";
+declare const _jsonTypes: readonly ["string", "number", "integer", "boolean", "null", "object", "array"];
+export type JSONType = (typeof _jsonTypes)[number];
+export declare function isJSONType(x: unknown): x is JSONType;
+type ValidationTypes = {
+    [K in JSONType]: boolean | RuleGroup | undefined;
+};
+export interface ValidationRules {
+    rules: RuleGroup[];
+    post: RuleGroup;
+    all: {
+        [Key in string]?: boolean | Rule;
+    };
+    keywords: {
+        [Key in string]?: boolean;
+    };
+    types: ValidationTypes;
+}
+export interface RuleGroup {
+    type?: JSONType;
+    rules: Rule[];
+}
+export interface Rule {
+    keyword: string;
+    definition: AddedKeywordDefinition;
+}
+export declare function getRules(): ValidationRules;
+export {};

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/rules.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRules = exports.isJSONType = void 0;
+const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
+const jsonTypes = new Set(_jsonTypes);
+function isJSONType(x) {
+    return typeof x == "string" && jsonTypes.has(x);
+}
+exports.isJSONType = isJSONType;
+function getRules() {
+    const groups = {
+        number: { type: "number", rules: [] },
+        string: { type: "string", rules: [] },
+        array: { type: "array", rules: [] },
+        object: { type: "object", rules: [] },
+    };
+    return {
+        types: { ...groups, integer: true, boolean: true, null: true },
+        rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
+        post: { rules: [] },
+        all: {},
+        keywords: {},
+    };
+}
+exports.getRules = getRules;
+//# sourceMappingURL=rules.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../lib/compile/rules.ts"],"names":[],"mappings":";;;AAEA,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAA;AAIjG,MAAM,SAAS,GAAgB,IAAI,GAAG,CAAC,UAAU,CAAC,CAAA;AAElD,SAAgB,UAAU,CAAC,CAAU;IACnC,OAAO,OAAO,CAAC,IAAI,QAAQ,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AACjD,CAAC;AAFD,gCAEC;AAyBD,SAAgB,QAAQ;IACtB,MAAM,MAAM,GAAgE;QAC1E,MAAM,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAC;QACnC,MAAM,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAC;QACnC,KAAK,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAC;QACjC,MAAM,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAC;KACpC,CAAA;IACD,OAAO;QACL,KAAK,EAAE,EAAC,GAAG,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC;QAC5D,KAAK,EAAE,CAAC,EAAC,KAAK,EAAE,EAAE,EAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;QAC/E,IAAI,EAAE,EAAC,KAAK,EAAE,EAAE,EAAC;QACjB,GAAG,EAAE,EAAE;QACP,QAAQ,EAAE,EAAE;KACb,CAAA;AACH,CAAC;AAdD,4BAcC"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/util.d.ts

@@ -0,0 +1,40 @@
+import type { AnySchema, EvaluatedProperties, EvaluatedItems } from "../types";
+import type { SchemaCxt, SchemaObjCxt } from ".";
+import { Code, Name, CodeGen } from "./codegen";
+import type { Rule, ValidationRules } from "./rules";
+export declare function toHash<T extends string = string>(arr: T[]): {
+    [K in T]?: true;
+};
+export declare function alwaysValidSchema(it: SchemaCxt, schema: AnySchema): boolean | void;
+export declare function checkUnknownRules(it: SchemaCxt, schema?: AnySchema): void;
+export declare function schemaHasRules(schema: AnySchema, rules: {
+    [Key in string]?: boolean | Rule;
+}): boolean;
+export declare function schemaHasRulesButRef(schema: AnySchema, RULES: ValidationRules): boolean;
+export declare function schemaRefOrVal({ topSchemaRef, schemaPath }: SchemaObjCxt, schema: unknown, keyword: string, $data?: string | false): Code | number | boolean;
+export declare function unescapeFragment(str: string): string;
+export declare function escapeFragment(str: string | number): string;
+export declare function escapeJsonPointer(str: string | number): string;
+export declare function unescapeJsonPointer(str: string): string;
+export declare function eachItem<T>(xs: T | T[], f: (x: T) => void): void;
+type SomeEvaluated = EvaluatedProperties | EvaluatedItems;
+type MergeEvaluatedFunc<T extends SomeEvaluated> = (gen: CodeGen, from: Name | T, to: Name | Exclude<T, true> | undefined, toName?: typeof Name) => Name | T;
+interface MergeEvaluated {
+    props: MergeEvaluatedFunc<EvaluatedProperties>;
+    items: MergeEvaluatedFunc<EvaluatedItems>;
+}
+export declare const mergeEvaluated: MergeEvaluated;
+export declare function evaluatedPropsToName(gen: CodeGen, ps?: EvaluatedProperties): Name;
+export declare function setEvaluated(gen: CodeGen, props: Name, ps: {
+    [K in string]?: true;
+}): void;
+export declare function useFunc(gen: CodeGen, f: {
+    code: string;
+}): Name;
+export declare enum Type {
+    Num = 0,
+    Str = 1
+}
+export declare function getErrorPath(dataProp: Name | string | number, dataPropType?: Type, jsPropertySyntax?: boolean): Code | string;
+export declare function checkStrictMode(it: SchemaCxt, msg: string, mode?: boolean | "log"): void;
+export {};

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/util.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
+const codegen_1 = require("./codegen");
+const code_1 = require("./codegen/code");
+// TODO refactor to use Set
+function toHash(arr) {
+    const hash = {};
+    for (const item of arr)
+        hash[item] = true;
+    return hash;
+}
+exports.toHash = toHash;
+function alwaysValidSchema(it, schema) {
+    if (typeof schema == "boolean")
+        return schema;
+    if (Object.keys(schema).length === 0)
+        return true;
+    checkUnknownRules(it, schema);
+    return !schemaHasRules(schema, it.self.RULES.all);
+}
+exports.alwaysValidSchema = alwaysValidSchema;
+function checkUnknownRules(it, schema = it.schema) {
+    const { opts, self } = it;
+    if (!opts.strictSchema)
+        return;
+    if (typeof schema === "boolean")
+        return;
+    const rules = self.RULES.keywords;
+    for (const key in schema) {
+        if (!rules[key])
+            checkStrictMode(it, `unknown keyword: "${key}"`);
+    }
+}
+exports.checkUnknownRules = checkUnknownRules;
+function schemaHasRules(schema, rules) {
+    if (typeof schema == "boolean")
+        return !schema;
+    for (const key in schema)
+        if (rules[key])
+            return true;
+    return false;
+}
+exports.schemaHasRules = schemaHasRules;
+function schemaHasRulesButRef(schema, RULES) {
+    if (typeof schema == "boolean")
+        return !schema;
+    for (const key in schema)
+        if (key !== "$ref" && RULES.all[key])
+            return true;
+    return false;
+}
+exports.schemaHasRulesButRef = schemaHasRulesButRef;
+function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
+    if (!$data) {
+        if (typeof schema == "number" || typeof schema == "boolean")
+            return schema;
+        if (typeof schema == "string")
+            return (0, codegen_1._) `${schema}`;
+    }
+    return (0, codegen_1._) `${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
+}
+exports.schemaRefOrVal = schemaRefOrVal;
+function unescapeFragment(str) {
+    return unescapeJsonPointer(decodeURIComponent(str));
+}
+exports.unescapeFragment = unescapeFragment;
+function escapeFragment(str) {
+    return encodeURIComponent(escapeJsonPointer(str));
+}
+exports.escapeFragment = escapeFragment;
+function escapeJsonPointer(str) {
+    if (typeof str == "number")
+        return `${str}`;
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+exports.escapeJsonPointer = escapeJsonPointer;
+function unescapeJsonPointer(str) {
+    return str.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+exports.unescapeJsonPointer = unescapeJsonPointer;
+function eachItem(xs, f) {
+    if (Array.isArray(xs)) {
+        for (const x of xs)
+            f(x);
+    }
+    else {
+        f(xs);
+    }
+}
+exports.eachItem = eachItem;
+function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName, }) {
+    return (gen, from, to, toName) => {
+        const res = to === undefined
+            ? from
+            : to instanceof codegen_1.Name
+                ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)
+                : from instanceof codegen_1.Name
+                    ? (mergeToName(gen, to, from), from)
+                    : mergeValues(from, to);
+        return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
+    };
+}
+exports.mergeEvaluated = {
+    props: makeMergeEvaluated({
+        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => {
+            gen.if((0, codegen_1._) `${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._) `${to} || {}`).code((0, codegen_1._) `Object.assign(${to}, ${from})`));
+        }),
+        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => {
+            if (from === true) {
+                gen.assign(to, true);
+            }
+            else {
+                gen.assign(to, (0, codegen_1._) `${to} || {}`);
+                setEvaluated(gen, to, from);
+            }
+        }),
+        mergeValues: (from, to) => (from === true ? true : { ...from, ...to }),
+        resultToName: evaluatedPropsToName,
+    }),
+    items: makeMergeEvaluated({
+        mergeNames: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._) `${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
+        mergeToName: (gen, from, to) => gen.if((0, codegen_1._) `${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._) `${to} > ${from} ? ${to} : ${from}`)),
+        mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
+        resultToName: (gen, items) => gen.var("items", items),
+    }),
+};
+function evaluatedPropsToName(gen, ps) {
+    if (ps === true)
+        return gen.var("props", true);
+    const props = gen.var("props", (0, codegen_1._) `{}`);
+    if (ps !== undefined)
+        setEvaluated(gen, props, ps);
+    return props;
+}
+exports.evaluatedPropsToName = evaluatedPropsToName;
+function setEvaluated(gen, props, ps) {
+    Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._) `${props}${(0, codegen_1.getProperty)(p)}`, true));
+}
+exports.setEvaluated = setEvaluated;
+const snippets = {};
+function useFunc(gen, f) {
+    return gen.scopeValue("func", {
+        ref: f,
+        code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)),
+    });
+}
+exports.useFunc = useFunc;
+var Type;
+(function (Type) {
+    Type[Type["Num"] = 0] = "Num";
+    Type[Type["Str"] = 1] = "Str";
+})(Type || (exports.Type = Type = {}));
+function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
+    // let path
+    if (dataProp instanceof codegen_1.Name) {
+        const isNumber = dataPropType === Type.Num;
+        return jsPropertySyntax
+            ? isNumber
+                ? (0, codegen_1._) `"[" + ${dataProp} + "]"`
+                : (0, codegen_1._) `"['" + ${dataProp} + "']"`
+            : isNumber
+                ? (0, codegen_1._) `"/" + ${dataProp}`
+                : (0, codegen_1._) `"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; // TODO maybe use global escapePointer
+    }
+    return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
+}
+exports.getErrorPath = getErrorPath;
+function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
+    if (!mode)
+        return;
+    msg = `strict mode: ${msg}`;
+    if (mode === true)
+        throw new Error(msg);
+    it.self.logger.warn(msg);
+}
+exports.checkStrictMode = checkStrictMode;
+//# sourceMappingURL=util.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/applicability.d.ts

@@ -0,0 +1,6 @@
+import type { AnySchemaObject } from "../../types";
+import type { SchemaObjCxt } from "..";
+import type { JSONType, RuleGroup, Rule } from "../rules";
+export declare function schemaHasRulesForType({ schema, self }: SchemaObjCxt, type: JSONType): boolean | undefined;
+export declare function shouldUseGroup(schema: AnySchemaObject, group: RuleGroup): boolean;
+export declare function shouldUseRule(schema: AnySchemaObject, rule: Rule): boolean | undefined;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/applicability.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
+function schemaHasRulesForType({ schema, self }, type) {
+    const group = self.RULES.types[type];
+    return group && group !== true && shouldUseGroup(schema, group);
+}
+exports.schemaHasRulesForType = schemaHasRulesForType;
+function shouldUseGroup(schema, group) {
+    return group.rules.some((rule) => shouldUseRule(schema, rule));
+}
+exports.shouldUseGroup = shouldUseGroup;
+function shouldUseRule(schema, rule) {
+    var _a;
+    return (schema[rule.keyword] !== undefined ||
+        ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== undefined)));
+}
+exports.shouldUseRule = shouldUseRule;
+//# sourceMappingURL=applicability.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/applicability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applicability.js","sourceRoot":"","sources":["../../../lib/compile/validate/applicability.ts"],"names":[],"mappings":";;;AAIA,SAAgB,qBAAqB,CACnC,EAAC,MAAM,EAAE,IAAI,EAAe,EAC5B,IAAc;IAEd,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACpC,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AACjE,CAAC;AAND,sDAMC;AAED,SAAgB,cAAc,CAAC,MAAuB,EAAE,KAAgB;IACtE,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;AAChE,CAAC;AAFD,wCAEC;AAED,SAAgB,aAAa,CAAC,MAAuB,EAAE,IAAU;;IAC/D,OAAO,CACL,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,SAAS;SAClC,MAAA,IAAI,CAAC,UAAU,CAAC,UAAU,0CAAE,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,CAAA,CACrE,CAAA;AACH,CAAC;AALD,sCAKC"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/boolSchema.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaCxt } from "..";
+import { Name } from "../codegen";
+export declare function topBoolOrEmptySchema(it: SchemaCxt): void;
+export declare function boolOrEmptySchema(it: SchemaCxt, valid: Name): void;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/boolSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
+const errors_1 = require("../errors");
+const codegen_1 = require("../codegen");
+const names_1 = require("../names");
+const boolError = {
+    message: "boolean schema is false",
+};
+function topBoolOrEmptySchema(it) {
+    const { gen, schema, validateName } = it;
+    if (schema === false) {
+        falseSchemaError(it, false);
+    }
+    else if (typeof schema == "object" && schema.$async === true) {
+        gen.return(names_1.default.data);
+    }
+    else {
+        gen.assign((0, codegen_1._) `${validateName}.errors`, null);
+        gen.return(true);
+    }
+}
+exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
+function boolOrEmptySchema(it, valid) {
+    const { gen, schema } = it;
+    if (schema === false) {
+        gen.var(valid, false); // TODO var
+        falseSchemaError(it);
+    }
+    else {
+        gen.var(valid, true); // TODO var
+    }
+}
+exports.boolOrEmptySchema = boolOrEmptySchema;
+function falseSchemaError(it, overrideAllErrors) {
+    const { gen, data } = it;
+    // TODO maybe some other interface should be used for non-keyword validation errors...
+    const cxt = {
+        gen,
+        keyword: "false schema",
+        data,
+        schema: false,
+        schemaCode: false,
+        schemaValue: false,
+        params: {},
+        it,
+    };
+    (0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors);
+}
+//# sourceMappingURL=boolSchema.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/boolSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolSchema.js","sourceRoot":"","sources":["../../../lib/compile/validate/boolSchema.ts"],"names":[],"mappings":";;;AAEA,sCAAqC;AACrC,wCAAkC;AAClC,oCAAwB;AAExB,MAAM,SAAS,GAA2B;IACxC,OAAO,EAAE,yBAAyB;CACnC,CAAA;AAED,SAAgB,oBAAoB,CAAC,EAAa;IAChD,MAAM,EAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAC,GAAG,EAAE,CAAA;IACtC,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;QACrB,gBAAgB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAA;IAC7B,CAAC;SAAM,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QAC/D,GAAG,CAAC,MAAM,CAAC,eAAC,CAAC,IAAI,CAAC,CAAA;IACpB,CAAC;SAAM,CAAC;QACN,GAAG,CAAC,MAAM,CAAC,IAAA,WAAC,EAAA,GAAG,YAAY,SAAS,EAAE,IAAI,CAAC,CAAA;QAC3C,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAClB,CAAC;AACH,CAAC;AAVD,oDAUC;AAED,SAAgB,iBAAiB,CAAC,EAAa,EAAE,KAAW;IAC1D,MAAM,EAAC,GAAG,EAAE,MAAM,EAAC,GAAG,EAAE,CAAA;IACxB,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;QACrB,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA,CAAC,WAAW;QACjC,gBAAgB,CAAC,EAAE,CAAC,CAAA;IACtB,CAAC;SAAM,CAAC;QACN,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA,CAAC,WAAW;IAClC,CAAC;AACH,CAAC;AARD,8CAQC;AAED,SAAS,gBAAgB,CAAC,EAAa,EAAE,iBAA2B;IAClE,MAAM,EAAC,GAAG,EAAE,IAAI,EAAC,GAAG,EAAE,CAAA;IACtB,sFAAsF;IACtF,MAAM,GAAG,GAAoB;QAC3B,GAAG;QACH,OAAO,EAAE,cAAc;QACvB,IAAI;QACJ,MAAM,EAAE,KAAK;QACb,UAAU,EAAE,KAAK;QACjB,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,EAAE;QACV,EAAE;KACH,CAAA;IACD,IAAA,oBAAW,EAAC,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAA;AAC3D,CAAC"}

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/dataType.d.ts

@@ -0,0 +1,17 @@
+import type { ErrorObject, AnySchemaObject } from "../../types";
+import type { SchemaObjCxt } from "..";
+import { JSONType } from "../rules";
+import { Code, Name } from "../codegen";
+export declare enum DataType {
+    Correct = 0,
+    Wrong = 1
+}
+export declare function getSchemaTypes(schema: AnySchemaObject): JSONType[];
+export declare function getJSONTypes(ts: unknown | unknown[]): JSONType[];
+export declare function coerceAndCheckDataType(it: SchemaObjCxt, types: JSONType[]): boolean;
+export declare function checkDataType(dataType: JSONType, data: Name, strictNums?: boolean | "log", correct?: DataType): Code;
+export declare function checkDataTypes(dataTypes: JSONType[], data: Name, strictNums?: boolean | "log", correct?: DataType): Code;
+export type TypeError = ErrorObject<"type", {
+    type: string;
+}>;
+export declare function reportTypeError(it: SchemaObjCxt): void;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/dataType.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
+const rules_1 = require("../rules");
+const applicability_1 = require("./applicability");
+const errors_1 = require("../errors");
+const codegen_1 = require("../codegen");
+const util_1 = require("../util");
+var DataType;
+(function (DataType) {
+    DataType[DataType["Correct"] = 0] = "Correct";
+    DataType[DataType["Wrong"] = 1] = "Wrong";
+})(DataType || (exports.DataType = DataType = {}));
+function getSchemaTypes(schema) {
+    const types = getJSONTypes(schema.type);
+    const hasNull = types.includes("null");
+    if (hasNull) {
+        if (schema.nullable === false)
+            throw new Error("type: null contradicts nullable: false");
+    }
+    else {
+        if (!types.length && schema.nullable !== undefined) {
+            throw new Error('"nullable" cannot be used without "type"');
+        }
+        if (schema.nullable === true)
+            types.push("null");
+    }
+    return types;
+}
+exports.getSchemaTypes = getSchemaTypes;
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+function getJSONTypes(ts) {
+    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types.every(rules_1.isJSONType))
+        return types;
+    throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
+}
+exports.getJSONTypes = getJSONTypes;
+function coerceAndCheckDataType(it, types) {
+    const { gen, data, opts } = it;
+    const coerceTo = coerceToTypes(types, opts.coerceTypes);
+    const checkTypes = types.length > 0 &&
+        !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
+    if (checkTypes) {
+        const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
+        gen.if(wrongType, () => {
+            if (coerceTo.length)
+                coerceData(it, types, coerceTo);
+            else
+                reportTypeError(it);
+        });
+    }
+    return checkTypes;
+}
+exports.coerceAndCheckDataType = coerceAndCheckDataType;
+const COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
+function coerceToTypes(types, coerceTypes) {
+    return coerceTypes
+        ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === "array" && t === "array"))
+        : [];
+}
+function coerceData(it, types, coerceTo) {
+    const { gen, data, opts } = it;
+    const dataType = gen.let("dataType", (0, codegen_1._) `typeof ${data}`);
+    const coerced = gen.let("coerced", (0, codegen_1._) `undefined`);
+    if (opts.coerceTypes === "array") {
+        gen.if((0, codegen_1._) `${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen
+            .assign(data, (0, codegen_1._) `${data}[0]`)
+            .assign(dataType, (0, codegen_1._) `typeof ${data}`)
+            .if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+    }
+    gen.if((0, codegen_1._) `${coerced} !== undefined`);
+    for (const t of coerceTo) {
+        if (COERCIBLE.has(t) || (t === "array" && opts.coerceTypes === "array")) {
+            coerceSpecificType(t);
+        }
+    }
+    gen.else();
+    reportTypeError(it);
+    gen.endIf();
+    gen.if((0, codegen_1._) `${coerced} !== undefined`, () => {
+        gen.assign(data, coerced);
+        assignParentData(it, coerced);
+    });
+    function coerceSpecificType(t) {
+        switch (t) {
+            case "string":
+                gen
+                    .elseIf((0, codegen_1._) `${dataType} == "number" || ${dataType} == "boolean"`)
+                    .assign(coerced, (0, codegen_1._) `"" + ${data}`)
+                    .elseIf((0, codegen_1._) `${data} === null`)
+                    .assign(coerced, (0, codegen_1._) `""`);
+                return;
+            case "number":
+                gen
+                    .elseIf((0, codegen_1._) `${dataType} == "boolean" || ${data} === null
+              || (${dataType} == "string" && ${data} && ${data} == +${data})`)
+                    .assign(coerced, (0, codegen_1._) `+${data}`);
+                return;
+            case "integer":
+                gen
+                    .elseIf((0, codegen_1._) `${dataType} === "boolean" || ${data} === null
+              || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`)
+                    .assign(coerced, (0, codegen_1._) `+${data}`);
+                return;
+            case "boolean":
+                gen
+                    .elseIf((0, codegen_1._) `${data} === "false" || ${data} === 0 || ${data} === null`)
+                    .assign(coerced, false)
+                    .elseIf((0, codegen_1._) `${data} === "true" || ${data} === 1`)
+                    .assign(coerced, true);
+                return;
+            case "null":
+                gen.elseIf((0, codegen_1._) `${data} === "" || ${data} === 0 || ${data} === false`);
+                gen.assign(coerced, null);
+                return;
+            case "array":
+                gen
+                    .elseIf((0, codegen_1._) `${dataType} === "string" || ${dataType} === "number"
+              || ${dataType} === "boolean" || ${data} === null`)
+                    .assign(coerced, (0, codegen_1._) `[${data}]`);
+        }
+    }
+}
+function assignParentData({ gen, parentData, parentDataProperty }, expr) {
+    // TODO use gen.property
+    gen.if((0, codegen_1._) `${parentData} !== undefined`, () => gen.assign((0, codegen_1._) `${parentData}[${parentDataProperty}]`, expr));
+}
+function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
+    const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
+    let cond;
+    switch (dataType) {
+        case "null":
+            return (0, codegen_1._) `${data} ${EQ} null`;
+        case "array":
+            cond = (0, codegen_1._) `Array.isArray(${data})`;
+            break;
+        case "object":
+            cond = (0, codegen_1._) `${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
+            break;
+        case "integer":
+            cond = numCond((0, codegen_1._) `!(${data} % 1) && !isNaN(${data})`);
+            break;
+        case "number":
+            cond = numCond();
+            break;
+        default:
+            return (0, codegen_1._) `typeof ${data} ${EQ} ${dataType}`;
+    }
+    return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
+    function numCond(_cond = codegen_1.nil) {
+        return (0, codegen_1.and)((0, codegen_1._) `typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._) `isFinite(${data})` : codegen_1.nil);
+    }
+}
+exports.checkDataType = checkDataType;
+function checkDataTypes(dataTypes, data, strictNums, correct) {
+    if (dataTypes.length === 1) {
+        return checkDataType(dataTypes[0], data, strictNums, correct);
+    }
+    let cond;
+    const types = (0, util_1.toHash)(dataTypes);
+    if (types.array && types.object) {
+        const notObj = (0, codegen_1._) `typeof ${data} != "object"`;
+        cond = types.null ? notObj : (0, codegen_1._) `!${data} || ${notObj}`;
+        delete types.null;
+        delete types.array;
+        delete types.object;
+    }
+    else {
+        cond = codegen_1.nil;
+    }
+    if (types.number)
+        delete types.integer;
+    for (const t in types)
+        cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
+    return cond;
+}
+exports.checkDataTypes = checkDataTypes;
+const typeError = {
+    message: ({ schema }) => `must be ${schema}`,
+    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._) `{type: ${schema}}` : (0, codegen_1._) `{type: ${schemaValue}}`,
+};
+function reportTypeError(it) {
+    const cxt = getTypeErrorContext(it);
+    (0, errors_1.reportError)(cxt, typeError);
+}
+exports.reportTypeError = reportTypeError;
+function getTypeErrorContext(it) {
+    const { gen, data, schema } = it;
+    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
+    return {
+        gen,
+        keyword: "type",
+        data,
+        schema: schema.type,
+        schemaCode,
+        schemaValue: schemaCode,
+        parentSchema: schema,
+        params: {},
+        it,
+    };
+}
+//# sourceMappingURL=dataType.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaObjCxt } from "..";
+export declare function assignDefaults(it: SchemaObjCxt, ty?: string): void;

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/defaults.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignDefaults = void 0;
+const codegen_1 = require("../codegen");
+const util_1 = require("../util");
+function assignDefaults(it, ty) {
+    const { properties, items } = it.schema;
+    if (ty === "object" && properties) {
+        for (const key in properties) {
+            assignDefault(it, key, properties[key].default);
+        }
+    }
+    else if (ty === "array" && Array.isArray(items)) {
+        items.forEach((sch, i) => assignDefault(it, i, sch.default));
+    }
+}
+exports.assignDefaults = assignDefaults;
+function assignDefault(it, prop, defaultValue) {
+    const { gen, compositeRule, data, opts } = it;
+    if (defaultValue === undefined)
+        return;
+    const childData = (0, codegen_1._) `${data}${(0, codegen_1.getProperty)(prop)}`;
+    if (compositeRule) {
+        (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
+        return;
+    }
+    let condition = (0, codegen_1._) `${childData} === undefined`;
+    if (opts.useDefaults === "empty") {
+        condition = (0, codegen_1._) `${condition} || ${childData} === null || ${childData} === ""`;
+    }
+    // `${childData} === undefined` +
+    // (opts.useDefaults === "empty" ? ` || ${childData} === null || ${childData} === ""` : "")
+    gen.if(condition, (0, codegen_1._) `${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
+}
+//# sourceMappingURL=defaults.js.map

node_modules/@apidevtools/swagger-parser/node_modules/ajv/dist/compile/validate/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../../lib/compile/validate/defaults.ts"],"names":[],"mappings":";;;AACA,wCAAoD;AACpD,kCAAuC;AAEvC,SAAgB,cAAc,CAAC,EAAgB,EAAE,EAAW;IAC1D,MAAM,EAAC,UAAU,EAAE,KAAK,EAAC,GAAG,EAAE,CAAC,MAAM,CAAA;IACrC,IAAI,EAAE,KAAK,QAAQ,IAAI,UAAU,EAAE,CAAC;QAClC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,aAAa,CAAC,EAAE,EAAE,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAA;QACjD,CAAC;IACH,CAAC;SAAM,IAAI,EAAE,KAAK,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAS,EAAE,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IACtE,CAAC;AACH,CAAC;AATD,wCASC;AAED,SAAS,aAAa,CAAC,EAAgB,EAAE,IAAqB,EAAE,YAAqB;IACnF,MAAM,EAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAC,GAAG,EAAE,CAAA;IAC3C,IAAI,YAAY,KAAK,SAAS;QAAE,OAAM;IACtC,MAAM,SAAS,GAAG,IAAA,WAAC,EAAA,GAAG,IAAI,GAAG,IAAA,qBAAW,EAAC,IAAI,CAAC,EAAE,CAAA;IAChD,IAAI,aAAa,EAAE,CAAC;QAClB,IAAA,sBAAe,EAAC,EAAE,EAAE,2BAA2B,SAAS,EAAE,CAAC,CAAA;QAC3D,OAAM;IACR,CAAC;IAED,IAAI,SAAS,GAAG,IAAA,WAAC,EAAA,GAAG,SAAS,gBAAgB,CAAA;IAC7C,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;QACjC,SAAS,GAAG,IAAA,WAAC,EAAA,GAAG,SAAS,OAAO,SAAS,gBAAgB,SAAS,SAAS,CAAA;IAC7E,CAAC;IACD,iCAAiC;IACjC,2FAA2F;IAC3F,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,IAAA,WAAC,EAAA,GAAG,SAAS,MAAM,IAAA,mBAAS,EAAC,YAAY,CAAC,EAAE,CAAC,CAAA;AACjE,CAAC"}