Initial commit: GamePortrait 竖屏版 - 深色豪华主题

node_modules/mini-css-extract-plugin/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+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/mini-css-extract-plugin/dist/hmr/hotModuleReplacement.js

@@ -0,0 +1,235 @@
+"use strict";
+
+/* eslint-env browser */
+/*
+  eslint-disable
+  no-console,
+  func-names
+*/
+
+/** @typedef {any} TODO */
+
+var normalizeUrl = require("./normalize-url");
+var srcByModuleId = Object.create(null);
+var noDocument = typeof document === "undefined";
+var forEach = Array.prototype.forEach;
+
+/**
+ * @param {function} fn
+ * @param {number} time
+ * @returns {(function(): void)|*}
+ */
+function debounce(fn, time) {
+  var timeout = 0;
+  return function () {
+    // @ts-ignore
+    var self = this;
+    // eslint-disable-next-line prefer-rest-params
+    var args = arguments;
+    var functionCall = function functionCall() {
+      return fn.apply(self, args);
+    };
+    clearTimeout(timeout);
+
+    // @ts-ignore
+    timeout = setTimeout(functionCall, time);
+  };
+}
+function noop() {}
+
+/**
+ * @param {TODO} moduleId
+ * @returns {TODO}
+ */
+function getCurrentScriptUrl(moduleId) {
+  var src = srcByModuleId[moduleId];
+  if (!src) {
+    if (document.currentScript) {
+      src = /** @type {HTMLScriptElement} */document.currentScript.src;
+    } else {
+      var scripts = document.getElementsByTagName("script");
+      var lastScriptTag = scripts[scripts.length - 1];
+      if (lastScriptTag) {
+        src = lastScriptTag.src;
+      }
+    }
+    srcByModuleId[moduleId] = src;
+  }
+
+  /**
+   * @param {string} fileMap
+   * @returns {null | string[]}
+   */
+  return function (fileMap) {
+    if (!src) {
+      return null;
+    }
+    var splitResult = src.split(/([^\\/]+)\.js$/);
+    var filename = splitResult && splitResult[1];
+    if (!filename) {
+      return [src.replace(".js", ".css")];
+    }
+    if (!fileMap) {
+      return [src.replace(".js", ".css")];
+    }
+    return fileMap.split(",").map(function (mapRule) {
+      var reg = new RegExp("".concat(filename, "\\.js$"), "g");
+      return normalizeUrl(src.replace(reg, "".concat(mapRule.replace(/{fileName}/g, filename), ".css")));
+    });
+  };
+}
+
+/**
+ * @param {TODO} el
+ * @param {string} [url]
+ */
+function updateCss(el, url) {
+  if (!url) {
+    if (!el.href) {
+      return;
+    }
+
+    // eslint-disable-next-line
+    url = el.href.split("?")[0];
+  }
+  if (!isUrlRequest( /** @type {string} */url)) {
+    return;
+  }
+  if (el.isLoaded === false) {
+    // We seem to be about to replace a css link that hasn't loaded yet.
+    // We're probably changing the same file more than once.
+    return;
+  }
+  if (!url || !(url.indexOf(".css") > -1)) {
+    return;
+  }
+
+  // eslint-disable-next-line no-param-reassign
+  el.visited = true;
+  var newEl = el.cloneNode();
+  newEl.isLoaded = false;
+  newEl.addEventListener("load", function () {
+    if (newEl.isLoaded) {
+      return;
+    }
+    newEl.isLoaded = true;
+    el.parentNode.removeChild(el);
+  });
+  newEl.addEventListener("error", function () {
+    if (newEl.isLoaded) {
+      return;
+    }
+    newEl.isLoaded = true;
+    el.parentNode.removeChild(el);
+  });
+  newEl.href = "".concat(url, "?").concat(Date.now());
+  if (el.nextSibling) {
+    el.parentNode.insertBefore(newEl, el.nextSibling);
+  } else {
+    el.parentNode.appendChild(newEl);
+  }
+}
+
+/**
+ * @param {string} href
+ * @param {TODO} src
+ * @returns {TODO}
+ */
+function getReloadUrl(href, src) {
+  var ret;
+
+  // eslint-disable-next-line no-param-reassign
+  href = normalizeUrl(href);
+  src.some(
+  /**
+   * @param {string} url
+   */
+  // eslint-disable-next-line array-callback-return
+  function (url) {
+    if (href.indexOf(src) > -1) {
+      ret = url;
+    }
+  });
+  return ret;
+}
+
+/**
+ * @param {string} [src]
+ * @returns {boolean}
+ */
+function reloadStyle(src) {
+  if (!src) {
+    return false;
+  }
+  var elements = document.querySelectorAll("link");
+  var loaded = false;
+  forEach.call(elements, function (el) {
+    if (!el.href) {
+      return;
+    }
+    var url = getReloadUrl(el.href, src);
+    if (!isUrlRequest(url)) {
+      return;
+    }
+    if (el.visited === true) {
+      return;
+    }
+    if (url) {
+      updateCss(el, url);
+      loaded = true;
+    }
+  });
+  return loaded;
+}
+function reloadAll() {
+  var elements = document.querySelectorAll("link");
+  forEach.call(elements, function (el) {
+    if (el.visited === true) {
+      return;
+    }
+    updateCss(el);
+  });
+}
+
+/**
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isUrlRequest(url) {
+  // An URL is not an request if
+
+  // It is not http or https
+  if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @param {TODO} moduleId
+ * @param {TODO} options
+ * @returns {TODO}
+ */
+module.exports = function (moduleId, options) {
+  if (noDocument) {
+    console.log("no window.document found, will not HMR CSS");
+    return noop;
+  }
+  var getScriptSrc = getCurrentScriptUrl(moduleId);
+  function update() {
+    var src = getScriptSrc(options.filename);
+    var reloaded = reloadStyle(src);
+    if (options.locals) {
+      console.log("[HMR] Detected local css modules. Reload all css");
+      reloadAll();
+      return;
+    }
+    if (reloaded) {
+      console.log("[HMR] css reload %s", src.join(" "));
+    } else {
+      console.log("[HMR] Reload all css");
+      reloadAll();
+    }
+  }
+  return debounce(update, 50);
+};

node_modules/mini-css-extract-plugin/dist/hmr/normalize-url.js

@@ -0,0 +1,39 @@
+"use strict";
+
+/* eslint-disable */
+
+/**
+ * @param {string[]} pathComponents
+ * @returns {string}
+ */
+function normalizeUrl(pathComponents) {
+  return pathComponents.reduce(function (accumulator, item) {
+    switch (item) {
+      case "..":
+        accumulator.pop();
+        break;
+      case ".":
+        break;
+      default:
+        accumulator.push(item);
+    }
+    return accumulator;
+  }, /** @type {string[]} */[]).join("/");
+}
+
+/**
+ * @param {string} urlString
+ * @returns {string}
+ */
+module.exports = function (urlString) {
+  urlString = urlString.trim();
+  if (/^data:/i.test(urlString)) {
+    return urlString;
+  }
+  var protocol = urlString.indexOf("//") !== -1 ? urlString.split("//")[0] + "//" : "";
+  var components = urlString.replace(new RegExp(protocol, "i"), "").split("/");
+  var host = components[0].toLowerCase().replace(/\.$/, "");
+  components[0] = "";
+  var path = normalizeUrl(components);
+  return protocol + host + path;
+};

node_modules/mini-css-extract-plugin/dist/index.js

@@ -0,0 +1,996 @@
+"use strict";
+
+/* eslint-disable class-methods-use-this */
+
+const path = require("path");
+const {
+  validate
+} = require("schema-utils");
+const schema = require("./plugin-options.json");
+const {
+  trueFn,
+  MODULE_TYPE,
+  AUTO_PUBLIC_PATH,
+  ABSOLUTE_PUBLIC_PATH,
+  SINGLE_DOT_PATH_SEGMENT,
+  compareModulesByIdentifier,
+  getUndoPath,
+  BASE_URI
+} = require("./utils");
+
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("webpack").ChunkGraph} ChunkGraph */
+/** @typedef {import("webpack").Chunk} Chunk */
+/** @typedef {Parameters<import("webpack").Chunk["isInGroup"]>[0]} ChunkGroup */
+/** @typedef {import("webpack").Module} Module */
+/** @typedef {import("webpack").Dependency} Dependency */
+/** @typedef {import("webpack").sources.Source} Source */
+/** @typedef {import("webpack").Configuration} Configuration */
+/** @typedef {import("webpack").WebpackError} WebpackError */
+/** @typedef {import("webpack").AssetInfo} AssetInfo */
+/** @typedef {import("./loader.js").Dependency} LoaderDependency */
+
+/**
+ * @typedef {Object} LoaderOptions
+ * @property {string | ((resourcePath: string, rootContext: string) => string)} [publicPath]
+ * @property {boolean} [emit]
+ * @property {boolean} [esModule]
+ * @property {string} [layer]
+ */
+
+/**
+ * @typedef {Object} PluginOptions
+ * @property {Required<Configuration>['output']['filename']} [filename]
+ * @property {Required<Configuration>['output']['chunkFilename']} [chunkFilename]
+ * @property {boolean} [ignoreOrder]
+ * @property {string | ((linkTag: HTMLLinkElement) => void)} [insert]
+ * @property {Record<string, string>} [attributes]
+ * @property {string | false | 'text/css'} [linkType]
+ * @property {boolean} [runtime]
+ * @property {boolean} [experimentalUseImportModule]
+ */
+
+/**
+ * @typedef {Object} NormalizedPluginOptions
+ * @property {Required<Configuration>['output']['filename']} filename
+ * @property {Required<Configuration>['output']['chunkFilename']} [chunkFilename]
+ * @property {boolean} ignoreOrder
+ * @property {string | ((linkTag: HTMLLinkElement) => void)} [insert]
+ * @property {Record<string, string>} [attributes]
+ * @property {string | false | 'text/css'} [linkType]
+ * @property {boolean} runtime
+ * @property {boolean} [experimentalUseImportModule]
+ */
+
+/**
+ * @typedef {Object} RuntimeOptions
+ * @property {string | ((linkTag: HTMLLinkElement) => void) | undefined} insert
+ * @property {string | false | 'text/css'} linkType
+ * @property {Record<string, string> | undefined} attributes
+ */
+
+/** @typedef {any} TODO */
+
+const pluginName = "mini-css-extract-plugin";
+const pluginSymbol = Symbol(pluginName);
+const DEFAULT_FILENAME = "[name].css";
+/**
+ * @type {Set<string>}
+ */
+const TYPES = new Set([MODULE_TYPE]);
+/**
+ * @type {ReturnType<Module["codeGeneration"]>}
+ */
+const CODE_GENERATION_RESULT = {
+  sources: new Map(),
+  runtimeRequirements: new Set()
+};
+
+/** @typedef {Module & { content: Buffer, media?: string, sourceMap?: Buffer, supports?: string, layer?: string, assets?: { [key: string]: TODO }, assetsInfo?: Map<string, AssetInfo> }} CssModule */
+
+/** @typedef {{ context: string | null, identifier: string, identifierIndex: number, content: Buffer, sourceMap?: Buffer, media?: string, supports?: string, layer?: TODO, assetsInfo?: Map<string, AssetInfo>, assets?: { [key: string]: TODO }}} CssModuleDependency */
+
+/** @typedef {{ new(dependency: CssModuleDependency): CssModule }} CssModuleConstructor */
+
+/** @typedef {Dependency & CssModuleDependency} CssDependency */
+
+/** @typedef {Omit<LoaderDependency, "context">} CssDependencyOptions */
+
+/** @typedef {{ new(loaderDependency: CssDependencyOptions, context: string | null, identifierIndex: number): CssDependency }} CssDependencyConstructor */
+
+/**
+ *
+ * @type {WeakMap<Compiler["webpack"], CssModuleConstructor>}
+ */
+const cssModuleCache = new WeakMap();
+/**
+ * @type {WeakMap<Compiler["webpack"], CssDependencyConstructor>}
+ */
+const cssDependencyCache = new WeakMap();
+/**
+ * @type {WeakSet<Compiler["webpack"]>}
+ */
+const registered = new WeakSet();
+class MiniCssExtractPlugin {
+  /**
+   * @param {Compiler["webpack"]} webpack
+   * @returns {CssModuleConstructor}
+   */
+  static getCssModule(webpack) {
+    /**
+     * Prevent creation of multiple CssModule classes to allow other integrations to get the current CssModule.
+     */
+    if (cssModuleCache.has(webpack)) {
+      return (/** @type {CssModuleConstructor} */cssModuleCache.get(webpack)
+      );
+    }
+    class CssModule extends webpack.Module {
+      /**
+       * @param {CssModuleDependency} dependency
+       */
+      constructor({
+        context,
+        identifier,
+        identifierIndex,
+        content,
+        layer,
+        supports,
+        media,
+        sourceMap,
+        assets,
+        assetsInfo
+      }) {
+        super(MODULE_TYPE, /** @type {string | undefined} */context);
+        this.id = "";
+        this._context = context;
+        this._identifier = identifier;
+        this._identifierIndex = identifierIndex;
+        this.content = content;
+        this.layer = layer;
+        this.supports = supports;
+        this.media = media;
+        this.sourceMap = sourceMap;
+        this.assets = assets;
+        this.assetsInfo = assetsInfo;
+        this._needBuild = true;
+      }
+
+      // no source() so webpack 4 doesn't do add stuff to the bundle
+
+      size() {
+        return this.content.length;
+      }
+      identifier() {
+        return `css|${this._identifier}|${this._identifierIndex}|${this.layer || ""}|${this.supports || ""}|${this.media}}}`;
+      }
+
+      /**
+       * @param {Parameters<Module["readableIdentifier"]>[0]} requestShortener
+       * @returns {ReturnType<Module["readableIdentifier"]>}
+       */
+      readableIdentifier(requestShortener) {
+        return `css ${requestShortener.shorten(this._identifier)}${this._identifierIndex ? ` (${this._identifierIndex})` : ""}${this.layer ? ` (layer ${this.layer})` : ""}${this.supports ? ` (supports ${this.supports})` : ""}${this.media ? ` (media ${this.media})` : ""}`;
+      }
+
+      // eslint-disable-next-line class-methods-use-this
+      getSourceTypes() {
+        return TYPES;
+      }
+
+      // eslint-disable-next-line class-methods-use-this
+      codeGeneration() {
+        return CODE_GENERATION_RESULT;
+      }
+      nameForCondition() {
+        const resource = /** @type {string} */
+        this._identifier.split("!").pop();
+        const idx = resource.indexOf("?");
+        if (idx >= 0) {
+          return resource.substring(0, idx);
+        }
+        return resource;
+      }
+
+      /**
+       * @param {Module} module
+       */
+      updateCacheModule(module) {
+        if (!this.content.equals( /** @type {CssModule} */module.content) || this.layer !== /** @type {CssModule} */module.layer || this.supports !== /** @type {CssModule} */module.supports || this.media !== /** @type {CssModule} */module.media || (this.sourceMap ? !this.sourceMap.equals( /** @type {Uint8Array} **/
+        /** @type {CssModule} */module.sourceMap) : false) || this.assets !== /** @type {CssModule} */module.assets || this.assetsInfo !== /** @type {CssModule} */module.assetsInfo) {
+          this._needBuild = true;
+          this.content = /** @type {CssModule} */module.content;
+          this.layer = /** @type {CssModule} */module.layer;
+          this.supports = /** @type {CssModule} */module.supports;
+          this.media = /** @type {CssModule} */module.media;
+          this.sourceMap = /** @type {CssModule} */module.sourceMap;
+          this.assets = /** @type {CssModule} */module.assets;
+          this.assetsInfo = /** @type {CssModule} */module.assetsInfo;
+        }
+      }
+
+      // eslint-disable-next-line class-methods-use-this
+      needRebuild() {
+        return this._needBuild;
+      }
+
+      // eslint-disable-next-line class-methods-use-this
+      /**
+       * @param {Parameters<Module["needBuild"]>[0]} context context info
+       * @param {Parameters<Module["needBuild"]>[1]} callback callback function, returns true, if the module needs a rebuild
+       */
+      needBuild(context, callback) {
+        // eslint-disable-next-line no-undefined
+        callback(undefined, this._needBuild);
+      }
+
+      /**
+       * @param {Parameters<Module["build"]>[0]} options
+       * @param {Parameters<Module["build"]>[1]} compilation
+       * @param {Parameters<Module["build"]>[2]} resolver
+       * @param {Parameters<Module["build"]>[3]} fileSystem
+       * @param {Parameters<Module["build"]>[4]} callback
+       */
+      build(options, compilation, resolver, fileSystem, callback) {
+        this.buildInfo = {
+          assets: this.assets,
+          assetsInfo: this.assetsInfo,
+          cacheable: true,
+          hash: this._computeHash( /** @type {string} */compilation.outputOptions.hashFunction)
+        };
+        this.buildMeta = {};
+        this._needBuild = false;
+        callback();
+      }
+
+      /**
+       * @private
+       * @param {string} hashFunction
+       * @returns {string | Buffer}
+       */
+      _computeHash(hashFunction) {
+        const hash = webpack.util.createHash(hashFunction);
+        hash.update(this.content);
+        if (this.layer) {
+          hash.update(this.layer);
+        }
+        hash.update(this.supports || "");
+        hash.update(this.media || "");
+        hash.update(this.sourceMap || "");
+        return hash.digest("hex");
+      }
+
+      /**
+       * @param {Parameters<Module["updateHash"]>[0]} hash
+       * @param {Parameters<Module["updateHash"]>[1]} context
+       */
+      updateHash(hash, context) {
+        super.updateHash(hash, context);
+        hash.update(this.buildInfo.hash);
+      }
+
+      /**
+       * @param {Parameters<Module["serialize"]>[0]} context
+       */
+      serialize(context) {
+        const {
+          write
+        } = context;
+        write(this._context);
+        write(this._identifier);
+        write(this._identifierIndex);
+        write(this.content);
+        write(this.layer);
+        write(this.supports);
+        write(this.media);
+        write(this.sourceMap);
+        write(this.assets);
+        write(this.assetsInfo);
+        write(this._needBuild);
+        super.serialize(context);
+      }
+
+      /**
+       * @param {Parameters<Module["deserialize"]>[0]} context
+       */
+      deserialize(context) {
+        this._needBuild = context.read();
+        super.deserialize(context);
+      }
+    }
+    cssModuleCache.set(webpack, CssModule);
+    webpack.util.serialization.register(CssModule, path.resolve(__dirname, "CssModule"),
+    // @ts-ignore
+    null, {
+      serialize(instance, context) {
+        instance.serialize(context);
+      },
+      deserialize(context) {
+        const {
+          read
+        } = context;
+        const contextModule = read();
+        const identifier = read();
+        const identifierIndex = read();
+        const content = read();
+        const layer = read();
+        const supports = read();
+        const media = read();
+        const sourceMap = read();
+        const assets = read();
+        const assetsInfo = read();
+        const dep = new CssModule({
+          context: contextModule,
+          identifier,
+          identifierIndex,
+          content,
+          layer,
+          supports,
+          media,
+          sourceMap,
+          assets,
+          assetsInfo
+        });
+        dep.deserialize(context);
+        return dep;
+      }
+    });
+    return CssModule;
+  }
+
+  /**
+   * @param {Compiler["webpack"]} webpack
+   * @returns {CssDependencyConstructor}
+   */
+  static getCssDependency(webpack) {
+    /**
+     * Prevent creation of multiple CssDependency classes to allow other integrations to get the current CssDependency.
+     */
+    if (cssDependencyCache.has(webpack)) {
+      return (/** @type {CssDependencyConstructor} */
+        cssDependencyCache.get(webpack)
+      );
+    }
+    class CssDependency extends webpack.Dependency {
+      /**
+       * @param {CssDependencyOptions} loaderDependency
+       * @param {string | null} context
+       * @param {number} identifierIndex
+       */
+      constructor({
+        identifier,
+        content,
+        layer,
+        supports,
+        media,
+        sourceMap
+      }, context, identifierIndex) {
+        super();
+        this.identifier = identifier;
+        this.identifierIndex = identifierIndex;
+        this.content = content;
+        this.layer = layer;
+        this.supports = supports;
+        this.media = media;
+        this.sourceMap = sourceMap;
+        this.context = context;
+        /** @type {{ [key: string]: Source } | undefined}} */
+        // eslint-disable-next-line no-undefined
+        this.assets = undefined;
+        /** @type {Map<string, AssetInfo> | undefined} */
+        // eslint-disable-next-line no-undefined
+        this.assetsInfo = undefined;
+      }
+
+      /**
+       * @returns {ReturnType<Dependency["getResourceIdentifier"]>}
+       */
+      getResourceIdentifier() {
+        return `css-module-${this.identifier}-${this.identifierIndex}`;
+      }
+
+      /**
+       * @returns {ReturnType<Dependency["getModuleEvaluationSideEffectsState"]>}
+       */
+      // eslint-disable-next-line class-methods-use-this
+      getModuleEvaluationSideEffectsState() {
+        return webpack.ModuleGraphConnection.TRANSITIVE_ONLY;
+      }
+
+      /**
+       * @param {Parameters<Dependency["serialize"]>[0]} context
+       */
+      serialize(context) {
+        const {
+          write
+        } = context;
+        write(this.identifier);
+        write(this.content);
+        write(this.layer);
+        write(this.supports);
+        write(this.media);
+        write(this.sourceMap);
+        write(this.context);
+        write(this.identifierIndex);
+        write(this.assets);
+        write(this.assetsInfo);
+        super.serialize(context);
+      }
+
+      /**
+       * @param {Parameters<Dependency["deserialize"]>[0]} context
+       */
+      deserialize(context) {
+        super.deserialize(context);
+      }
+    }
+    cssDependencyCache.set(webpack, CssDependency);
+    webpack.util.serialization.register(CssDependency, path.resolve(__dirname, "CssDependency"),
+    // @ts-ignore
+    null, {
+      serialize(instance, context) {
+        instance.serialize(context);
+      },
+      deserialize(context) {
+        const {
+          read
+        } = context;
+        const dep = new CssDependency({
+          identifier: read(),
+          content: read(),
+          layer: read(),
+          supports: read(),
+          media: read(),
+          sourceMap: read()
+        }, read(), read());
+        const assets = read();
+        const assetsInfo = read();
+        dep.assets = assets;
+        dep.assetsInfo = assetsInfo;
+        dep.deserialize(context);
+        return dep;
+      }
+    });
+    return CssDependency;
+  }
+
+  /**
+   * @param {PluginOptions} [options]
+   */
+  constructor(options = {}) {
+    validate( /** @type {Schema} */schema, options, {
+      baseDataPath: "options"
+    });
+
+    /**
+     * @private
+     * @type {WeakMap<Chunk, Set<CssModule>>}
+     * @private
+     */
+    this._sortedModulesCache = new WeakMap();
+
+    /**
+     * @private
+     * @type {NormalizedPluginOptions}
+     */
+    this.options = Object.assign({
+      filename: DEFAULT_FILENAME,
+      ignoreOrder: false,
+      // TODO remove in the next major release
+      // eslint-disable-next-line no-undefined
+      experimentalUseImportModule: undefined,
+      runtime: true
+    }, options);
+
+    /**
+     * @private
+     * @type {RuntimeOptions}
+     */
+    this.runtimeOptions = {
+      insert: options.insert,
+      linkType:
+      // Todo in next major release set default to "false"
+      typeof options.linkType === "boolean" && /** @type {boolean} */options.linkType === true || typeof options.linkType === "undefined" ? "text/css" : options.linkType,
+      attributes: options.attributes
+    };
+    if (!this.options.chunkFilename) {
+      const {
+        filename
+      } = this.options;
+      if (typeof filename !== "function") {
+        const hasName = /** @type {string} */filename.includes("[name]");
+        const hasId = /** @type {string} */filename.includes("[id]");
+        const hasChunkHash = /** @type {string} */
+        filename.includes("[chunkhash]");
+        const hasContentHash = /** @type {string} */
+        filename.includes("[contenthash]");
+
+        // Anything changing depending on chunk is fine
+        if (hasChunkHash || hasContentHash || hasName || hasId) {
+          this.options.chunkFilename = filename;
+        } else {
+          // Otherwise prefix "[id]." in front of the basename to make it changing
+          this.options.chunkFilename = /** @type {string} */
+          filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
+        }
+      } else {
+        this.options.chunkFilename = "[id].css";
+      }
+    }
+  }
+
+  /**
+   * @param {Compiler} compiler
+   */
+  apply(compiler) {
+    const {
+      webpack
+    } = compiler;
+    if (this.options.experimentalUseImportModule) {
+      if (typeof /** @type {Compiler["options"]["experiments"] & { executeModule?: boolean }} */
+      compiler.options.experiments.executeModule === "undefined") {
+        /** @type {Compiler["options"]["experiments"] & { executeModule?: boolean }} */
+        // eslint-disable-next-line no-param-reassign
+        compiler.options.experiments.executeModule = true;
+      }
+    }
+
+    // TODO bug in webpack, remove it after it will be fixed
+    // webpack tries to `require` loader firstly when serializer doesn't found
+    if (!registered.has(webpack)) {
+      registered.add(webpack);
+      webpack.util.serialization.registerLoader(/^mini-css-extract-plugin\//, trueFn);
+    }
+    const {
+      splitChunks
+    } = compiler.options.optimization;
+    if (splitChunks) {
+      if ( /** @type {string[]} */splitChunks.defaultSizeTypes.includes("...")) {
+        /** @type {string[]} */
+        splitChunks.defaultSizeTypes.push(MODULE_TYPE);
+      }
+    }
+    const CssModule = MiniCssExtractPlugin.getCssModule(webpack);
+    const CssDependency = MiniCssExtractPlugin.getCssDependency(webpack);
+    const {
+      NormalModule
+    } = compiler.webpack;
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      const {
+        loader: normalModuleHook
+      } = NormalModule.getCompilationHooks(compilation);
+      normalModuleHook.tap(pluginName,
+      /**
+       * @param {object} loaderContext
+       */
+      loaderContext => {
+        /** @type {object & { [pluginSymbol]: { experimentalUseImportModule: boolean | undefined } }} */
+        // eslint-disable-next-line no-param-reassign
+        loaderContext[pluginSymbol] = {
+          experimentalUseImportModule: this.options.experimentalUseImportModule
+        };
+      });
+    });
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      class CssModuleFactory {
+        /**
+         * @param {{ dependencies: Dependency[] }} dependencies
+         * @param {(arg0?: Error, arg1?: TODO) => void} callback
+         */
+        // eslint-disable-next-line class-methods-use-this
+        create({
+          dependencies: [dependency]
+        }, callback) {
+          callback(
+          // eslint-disable-next-line no-undefined
+          undefined, new CssModule( /** @type {CssDependency} */dependency));
+        }
+      }
+      compilation.dependencyFactories.set(CssDependency, new CssModuleFactory());
+      class CssDependencyTemplate {
+        // eslint-disable-next-line class-methods-use-this
+        apply() {}
+      }
+      compilation.dependencyTemplates.set(CssDependency, new CssDependencyTemplate());
+      compilation.hooks.renderManifest.tap(pluginName,
+      /**
+       * @param {ReturnType<Compilation["getRenderManifest"]>} result
+       * @param {Parameters<Compilation["getRenderManifest"]>[0]} chunk
+       * @returns {TODO}
+       */
+      (result, {
+        chunk
+      }) => {
+        const {
+          chunkGraph
+        } = compilation;
+        const {
+          HotUpdateChunk
+        } = webpack;
+
+        // We don't need hot update chunks for css
+        // We will use the real asset instead to update
+        if (chunk instanceof HotUpdateChunk) {
+          return;
+        }
+
+        /** @type {CssModule[]} */
+        const renderedModules = Array.from( /** @type {CssModule[]} */
+        this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === MODULE_TYPE);
+        const filenameTemplate = /** @type {string} */
+
+        chunk.canBeInitial() ? this.options.filename : this.options.chunkFilename;
+        if (renderedModules.length > 0) {
+          result.push({
+            render: () => this.renderContentAsset(compiler, compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener, filenameTemplate, {
+              contentHashType: MODULE_TYPE,
+              chunk
+            }),
+            filenameTemplate,
+            pathOptions: {
+              chunk,
+              contentHashType: MODULE_TYPE
+            },
+            identifier: `${pluginName}.${chunk.id}`,
+            hash: chunk.contentHash[MODULE_TYPE]
+          });
+        }
+      });
+      compilation.hooks.contentHash.tap(pluginName, chunk => {
+        const {
+          outputOptions,
+          chunkGraph
+        } = compilation;
+        const modules = this.sortModules(compilation, chunk, /** @type {CssModule[]} */
+        chunkGraph.getChunkModulesIterableBySourceType(chunk, MODULE_TYPE), compilation.runtimeTemplate.requestShortener);
+        if (modules) {
+          const {
+            hashFunction,
+            hashDigest,
+            hashDigestLength
+          } = outputOptions;
+          const {
+            createHash
+          } = compiler.webpack.util;
+          const hash = createHash( /** @type {string} */hashFunction);
+          for (const m of modules) {
+            hash.update(chunkGraph.getModuleHash(m, chunk.runtime));
+          }
+
+          // eslint-disable-next-line no-param-reassign
+          chunk.contentHash[MODULE_TYPE] = /** @type {string} */
+          hash.digest(hashDigest).substring(0, hashDigestLength);
+        }
+      });
+
+      // All the code below is dedicated to the runtime and can be skipped when the `runtime` option is `false`
+      if (!this.options.runtime) {
+        return;
+      }
+      const {
+        Template,
+        RuntimeGlobals,
+        RuntimeModule,
+        runtime
+      } = webpack;
+
+      /**
+       * @param {Chunk} mainChunk
+       * @param {Compilation} compilation
+       * @returns {Record<string, number>}
+       */
+      // eslint-disable-next-line no-shadow
+      const getCssChunkObject = (mainChunk, compilation) => {
+        /** @type {Record<string, number>} */
+        const obj = {};
+        const {
+          chunkGraph
+        } = compilation;
+        for (const chunk of mainChunk.getAllAsyncChunks()) {
+          const modules = chunkGraph.getOrderedChunkModulesIterable(chunk, compareModulesByIdentifier);
+          for (const module of modules) {
+            if (module.type === MODULE_TYPE) {
+              obj[/** @type {string} */chunk.id] = 1;
+              break;
+            }
+          }
+        }
+        return obj;
+      };
+      class CssLoadingRuntimeModule extends RuntimeModule {
+        /**
+         * @param {Set<string>} runtimeRequirements
+         * @param {RuntimeOptions} runtimeOptions
+         */
+        constructor(runtimeRequirements, runtimeOptions) {
+          super("css loading", 10);
+          this.runtimeRequirements = runtimeRequirements;
+          this.runtimeOptions = runtimeOptions;
+        }
+        generate() {
+          const {
+            chunk,
+            runtimeRequirements
+          } = this;
+          const {
+            runtimeTemplate,
+            outputOptions: {
+              crossOriginLoading
+            }
+          } = this.compilation;
+          const chunkMap = getCssChunkObject(chunk, this.compilation);
+          const withLoading = runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) && Object.keys(chunkMap).length > 0;
+          const withHmr = runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers);
+          if (!withLoading && !withHmr) {
+            return "";
+          }
+          return Template.asString(['if (typeof document === "undefined") return;', `var createStylesheet = ${runtimeTemplate.basicFunction("chunkId, fullhref, oldTag, resolve, reject", ['var linkTag = document.createElement("link");', this.runtimeOptions.attributes ? Template.asString(Object.entries(this.runtimeOptions.attributes).map(entry => {
+            const [key, value] = entry;
+            return `linkTag.setAttribute(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
+          })) : "", 'linkTag.rel = "stylesheet";', this.runtimeOptions.linkType ? `linkTag.type = ${JSON.stringify(this.runtimeOptions.linkType)};` : "", `var onLinkComplete = ${runtimeTemplate.basicFunction("event", ["// avoid mem leaks.", "linkTag.onerror = linkTag.onload = null;", "if (event.type === 'load') {", Template.indent(["resolve();"]), "} else {", Template.indent(["var errorType = event && (event.type === 'load' ? 'missing' : event.type);", "var realHref = event && event.target && event.target.href || fullhref;", 'var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + realHref + ")");', 'err.code = "CSS_CHUNK_LOAD_FAILED";', "err.type = errorType;", "err.request = realHref;", "if (linkTag.parentNode) linkTag.parentNode.removeChild(linkTag)", "reject(err);"]), "}"])}`, "linkTag.onerror = linkTag.onload = onLinkComplete;", "linkTag.href = fullhref;", crossOriginLoading ? Template.asString([`if (linkTag.href.indexOf(window.location.origin + '/') !== 0) {`, Template.indent(`linkTag.crossOrigin = ${JSON.stringify(crossOriginLoading)};`), "}"]) : "", typeof this.runtimeOptions.insert !== "undefined" ? typeof this.runtimeOptions.insert === "function" ? `(${this.runtimeOptions.insert.toString()})(linkTag)` : Template.asString([`var target = document.querySelector("${this.runtimeOptions.insert}");`, `target.parentNode.insertBefore(linkTag, target.nextSibling);`]) : Template.asString(["if (oldTag) {", Template.indent(["oldTag.parentNode.insertBefore(linkTag, oldTag.nextSibling);"]), "} else {", Template.indent(["document.head.appendChild(linkTag);"]), "}"]), "return linkTag;"])};`, `var findStylesheet = ${runtimeTemplate.basicFunction("href, fullhref", ['var existingLinkTags = document.getElementsByTagName("link");', "for(var i = 0; i < existingLinkTags.length; i++) {", Template.indent(["var tag = existingLinkTags[i];", 'var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");', 'if(tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;']), "}", 'var existingStyleTags = document.getElementsByTagName("style");', "for(var i = 0; i < existingStyleTags.length; i++) {", Template.indent(["var tag = existingStyleTags[i];", 'var dataHref = tag.getAttribute("data-href");', "if(dataHref === href || dataHref === fullhref) return tag;"]), "}"])};`, `var loadStylesheet = ${runtimeTemplate.basicFunction("chunkId", `return new Promise(${runtimeTemplate.basicFunction("resolve, reject", [`var href = ${RuntimeGlobals.require}.miniCssF(chunkId);`, `var fullhref = ${RuntimeGlobals.publicPath} + href;`, "if(findStylesheet(href, fullhref)) return resolve();", "createStylesheet(chunkId, fullhref, null, resolve, reject);"])});`)}`, withLoading ? Template.asString(["// object to store loaded CSS chunks", "var installedCssChunks = {", Template.indent( /** @type {string[]} */
+          chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(",\n")), "};", "", `${RuntimeGlobals.ensureChunkHandlers}.miniCss = ${runtimeTemplate.basicFunction("chunkId, promises", [`var cssChunks = ${JSON.stringify(chunkMap)};`, "if(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);", "else if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {", Template.indent([`promises.push(installedCssChunks[chunkId] = loadStylesheet(chunkId).then(${runtimeTemplate.basicFunction("", "installedCssChunks[chunkId] = 0;")}, ${runtimeTemplate.basicFunction("e", ["delete installedCssChunks[chunkId];", "throw e;"])}));`]), "}"])};`]) : "// no chunk loading", "", withHmr ? Template.asString(["var oldTags = [];", "var newTags = [];", `var applyHandler = ${runtimeTemplate.basicFunction("options", [`return { dispose: ${runtimeTemplate.basicFunction("", ["for(var i = 0; i < oldTags.length; i++) {", Template.indent(["var oldTag = oldTags[i];", "if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);"]), "}", "oldTags.length = 0;"])}, apply: ${runtimeTemplate.basicFunction("", ['for(var i = 0; i < newTags.length; i++) newTags[i].rel = "stylesheet";', "newTags.length = 0;"])} };`])}`, `${RuntimeGlobals.hmrDownloadUpdateHandlers}.miniCss = ${runtimeTemplate.basicFunction("chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList", ["applyHandlers.push(applyHandler);", `chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [`var href = ${RuntimeGlobals.require}.miniCssF(chunkId);`, `var fullhref = ${RuntimeGlobals.publicPath} + href;`, "var oldTag = findStylesheet(href, fullhref);", "if(!oldTag) return;", `promises.push(new Promise(${runtimeTemplate.basicFunction("resolve, reject", [`var tag = createStylesheet(chunkId, fullhref, oldTag, ${runtimeTemplate.basicFunction("", ['tag.as = "style";', 'tag.rel = "preload";', "resolve();"])}, reject);`, "oldTags.push(oldTag);", "newTags.push(tag);"])}));`])});`])}`]) : "// no hmr"]);
+        }
+      }
+      const enabledChunks = new WeakSet();
+
+      /**
+       * @param {Chunk} chunk
+       * @param {Set<string>} set
+       */
+      const handler = (chunk, set) => {
+        if (enabledChunks.has(chunk)) {
+          return;
+        }
+        enabledChunks.add(chunk);
+        if (typeof this.options.chunkFilename === "string" && /\[(full)?hash(:\d+)?\]/.test(this.options.chunkFilename)) {
+          set.add(RuntimeGlobals.getFullHash);
+        }
+        set.add(RuntimeGlobals.publicPath);
+        compilation.addRuntimeModule(chunk, new runtime.GetChunkFilenameRuntimeModule(MODULE_TYPE, "mini-css", `${RuntimeGlobals.require}.miniCssF`,
+        /**
+         * @param {Chunk} referencedChunk
+         * @returns {TODO}
+         */
+        referencedChunk => {
+          if (!referencedChunk.contentHash[MODULE_TYPE]) {
+            return false;
+          }
+          return referencedChunk.canBeInitial() ? this.options.filename : this.options.chunkFilename;
+        }, false));
+        compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set, this.runtimeOptions));
+      };
+      compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.ensureChunkHandlers).tap(pluginName, handler);
+      compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.hmrDownloadUpdateHandlers).tap(pluginName, handler);
+    });
+  }
+
+  /**
+   * @private
+   * @param {Chunk} chunk
+   * @param {ChunkGraph} chunkGraph
+   * @returns {Iterable<Module>}
+   */
+  getChunkModules(chunk, chunkGraph) {
+    return typeof chunkGraph !== "undefined" ? chunkGraph.getOrderedChunkModulesIterable(chunk, compareModulesByIdentifier) : chunk.modulesIterable;
+  }
+
+  /**
+   * @private
+   * @param {Compilation} compilation
+   * @param {Chunk} chunk
+   * @param {CssModule[]} modules
+   * @param {Compilation["requestShortener"]} requestShortener
+   * @returns {Set<CssModule>}
+   */
+  sortModules(compilation, chunk, modules, requestShortener) {
+    let usedModules = this._sortedModulesCache.get(chunk);
+    if (usedModules || !modules) {
+      return (/** @type {Set<CssModule>} */usedModules
+      );
+    }
+
+    /** @type {CssModule[]} */
+    const modulesList = [...modules];
+    // Store dependencies for modules
+    /** @type {Map<CssModule, Set<CssModule>>} */
+    const moduleDependencies = new Map(modulesList.map(m => [m, /** @type {Set<CssModule>} */
+    new Set()]));
+    /** @type {Map<CssModule, Map<CssModule, Set<ChunkGroup>>>} */
+    const moduleDependenciesReasons = new Map(modulesList.map(m => [m, new Map()]));
+    // Get ordered list of modules per chunk group
+    // This loop also gathers dependencies from the ordered lists
+    // Lists are in reverse order to allow to use Array.pop()
+    /** @type {CssModule[][]} */
+    const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
+      const sortedModules = modulesList.map(module => {
+        return {
+          module,
+          index: chunkGroup.getModulePostOrderIndex(module)
+        };
+      })
+      // eslint-disable-next-line no-undefined
+      .filter(item => item.index !== undefined).sort((a, b) => b.index - a.index).map(item => item.module);
+      for (let i = 0; i < sortedModules.length; i++) {
+        const set = moduleDependencies.get(sortedModules[i]);
+        const reasons = /** @type {Map<CssModule, Set<ChunkGroup>>} */
+        moduleDependenciesReasons.get(sortedModules[i]);
+        for (let j = i + 1; j < sortedModules.length; j++) {
+          const module = sortedModules[j];
+
+          /** @type {Set<CssModule>} */
+          set.add(module);
+          const reason = reasons.get(module) || /** @type {Set<ChunkGroup>} */new Set();
+          reason.add(chunkGroup);
+          reasons.set(module, reason);
+        }
+      }
+      return sortedModules;
+    });
+
+    // set with already included modules in correct order
+    usedModules = new Set();
+
+    /**
+     * @param {CssModule} m
+     * @returns {boolean}
+     */
+    const unusedModulesFilter = m => ! /** @type {Set<CssModule>} */usedModules.has(m);
+    while (usedModules.size < modulesList.length) {
+      let success = false;
+      let bestMatch;
+      let bestMatchDeps;
+
+      // get first module where dependencies are fulfilled
+      for (const list of modulesByChunkGroup) {
+        // skip and remove already added modules
+        while (list.length > 0 && usedModules.has(list[list.length - 1])) {
+          list.pop();
+        }
+
+        // skip empty lists
+        if (list.length !== 0) {
+          const module = list[list.length - 1];
+          const deps = moduleDependencies.get(module);
+          // determine dependencies that are not yet included
+          const failedDeps = Array.from( /** @type {Set<CssModule>} */
+          deps).filter(unusedModulesFilter);
+
+          // store best match for fallback behavior
+          if (!bestMatchDeps || bestMatchDeps.length > failedDeps.length) {
+            bestMatch = list;
+            bestMatchDeps = failedDeps;
+          }
+          if (failedDeps.length === 0) {
+            // use this module and remove it from list
+            usedModules.add( /** @type {CssModule} */list.pop());
+            success = true;
+            break;
+          }
+        }
+      }
+      if (!success) {
+        // no module found => there is a conflict
+        // use list with fewest failed deps
+        // and emit a warning
+        const fallbackModule = /** @type {CssModule[]} */bestMatch.pop();
+        if (!this.options.ignoreOrder) {
+          const reasons = moduleDependenciesReasons.get( /** @type {CssModule} */fallbackModule);
+          compilation.warnings.push( /** @type {WebpackError} */
+
+          new Error([`chunk ${chunk.name || chunk.id} [${pluginName}]`, "Conflicting order. Following module has been added:", ` * ${
+          /** @type {CssModule} */fallbackModule.readableIdentifier(requestShortener)}`, "despite it was not able to fulfill desired ordering with these modules:", ... /** @type {CssModule[]} */bestMatchDeps.map(m => {
+            const goodReasonsMap = moduleDependenciesReasons.get(m);
+            const goodReasons = goodReasonsMap && goodReasonsMap.get( /** @type {CssModule} */fallbackModule);
+            const failedChunkGroups = Array.from( /** @type {Set<ChunkGroup>} */
+
+            /** @type {Map<CssModule, Set<ChunkGroup>>} */
+            reasons.get(m), cg => cg.name).join(", ");
+            const goodChunkGroups = goodReasons && Array.from(goodReasons, cg => cg.name).join(", ");
+            return [` * ${m.readableIdentifier(requestShortener)}`, `   - couldn't fulfill desired order of chunk group(s) ${failedChunkGroups}`, goodChunkGroups && `   - while fulfilling desired order of chunk group(s) ${goodChunkGroups}`].filter(Boolean).join("\n");
+          })].join("\n")));
+        }
+        usedModules.add( /** @type {CssModule} */fallbackModule);
+      }
+    }
+    this._sortedModulesCache.set(chunk, usedModules);
+    return usedModules;
+  }
+
+  /**
+   * @private
+   * @param {Compiler} compiler
+   * @param {Compilation} compilation
+   * @param {Chunk} chunk
+   * @param {CssModule[]} modules
+   * @param {Compiler["requestShortener"]} requestShortener
+   * @param {string} filenameTemplate
+   * @param {Parameters<Exclude<Required<Configuration>['output']['filename'], string | undefined>>[0]} pathData
+   * @returns {Source}
+   */
+  renderContentAsset(compiler, compilation, chunk, modules, requestShortener, filenameTemplate, pathData) {
+    const usedModules = this.sortModules(compilation, chunk, modules, requestShortener);
+    const {
+      ConcatSource,
+      SourceMapSource,
+      RawSource
+    } = compiler.webpack.sources;
+    const source = new ConcatSource();
+    const externalsSource = new ConcatSource();
+    for (const module of usedModules) {
+      let content = module.content.toString();
+      const readableIdentifier = module.readableIdentifier(requestShortener);
+      const startsWithAtRuleImport = /^@import url/.test(content);
+      let header;
+      if (compilation.outputOptions.pathinfo) {
+        // From https://github.com/webpack/webpack/blob/29eff8a74ecc2f87517b627dee451c2af9ed3f3f/lib/ModuleInfoHeaderPlugin.js#L191-L194
+        const reqStr = readableIdentifier.replace(/\*\//g, "*_/");
+        const reqStrStar = "*".repeat(reqStr.length);
+        const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
+        header = new RawSource(headerStr);
+      }
+      if (startsWithAtRuleImport) {
+        if (typeof header !== "undefined") {
+          externalsSource.add(header);
+        }
+
+        // HACK for IE
+        // http://stackoverflow.com/a/14676665/1458162
+        if (module.media) {
+          // insert media into the @import
+          // this is rar
+          // TODO improve this and parse the CSS to support multiple medias
+          content = content.replace(/;|\s*$/, module.media);
+        }
+        externalsSource.add(content);
+        externalsSource.add("\n");
+      } else {
+        if (typeof header !== "undefined") {
+          source.add(header);
+        }
+        if (module.supports) {
+          source.add(`@supports (${module.supports}) {\n`);
+        }
+        if (module.media) {
+          source.add(`@media ${module.media} {\n`);
+        }
+        const needLayer = typeof module.layer !== "undefined";
+        if (needLayer) {
+          source.add(`@layer${module.layer.length > 0 ? ` ${module.layer}` : ""} {\n`);
+        }
+        const {
+          path: filename
+        } = compilation.getPathWithInfo(filenameTemplate, pathData);
+        const undoPath = getUndoPath(filename, compiler.outputPath, false);
+
+        // replacements
+        content = content.replace(new RegExp(ABSOLUTE_PUBLIC_PATH, "g"), "");
+        content = content.replace(new RegExp(SINGLE_DOT_PATH_SEGMENT, "g"), ".");
+        content = content.replace(new RegExp(AUTO_PUBLIC_PATH, "g"), undoPath);
+        const entryOptions = chunk.getEntryOptions();
+        const baseUriReplacement = entryOptions && entryOptions.baseUri || undoPath;
+        content = content.replace(new RegExp(BASE_URI, "g"), baseUriReplacement);
+        if (module.sourceMap) {
+          source.add(new SourceMapSource(content, readableIdentifier, module.sourceMap.toString()));
+        } else {
+          source.add(new RawSource(content));
+        }
+        source.add("\n");
+        if (needLayer) {
+          source.add("}\n");
+        }
+        if (module.media) {
+          source.add("}\n");
+        }
+        if (module.supports) {
+          source.add("}\n");
+        }
+      }
+    }
+    return new ConcatSource(externalsSource, source);
+  }
+}
+MiniCssExtractPlugin.pluginName = pluginName;
+MiniCssExtractPlugin.pluginSymbol = pluginSymbol;
+MiniCssExtractPlugin.loader = require.resolve("./loader");
+module.exports = MiniCssExtractPlugin;

node_modules/mini-css-extract-plugin/dist/loader-options.json

@@ -0,0 +1,32 @@
+{
+  "title": "Mini CSS Extract Plugin Loader options",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "publicPath": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "Specifies a custom public path for the external resources like images, files, etc inside CSS.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#publicpath"
+    },
+    "emit": {
+      "type": "boolean",
+      "description": "If true, emits a file (writes a file to the filesystem). If false, the plugin will extract the CSS but will not emit the file",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#emit"
+    },
+    "esModule": {
+      "type": "boolean",
+      "description": "Generates JS modules that use the ES modules syntax.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#esmodule"
+    },
+    "layer": {
+      "type": "string"
+    }
+  }
+}

node_modules/mini-css-extract-plugin/dist/loader.js

@@ -0,0 +1,374 @@
+"use strict";
+
+const path = require("path");
+const {
+  findModuleById,
+  evalModuleCode,
+  AUTO_PUBLIC_PATH,
+  ABSOLUTE_PUBLIC_PATH,
+  BASE_URI,
+  SINGLE_DOT_PATH_SEGMENT,
+  stringifyRequest,
+  stringifyLocal
+} = require("./utils");
+const schema = require("./loader-options.json");
+const MiniCssExtractPlugin = require("./index");
+
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("webpack").Chunk} Chunk */
+/** @typedef {import("webpack").Module} Module */
+/** @typedef {import("webpack").sources.Source} Source */
+/** @typedef {import("webpack").AssetInfo} AssetInfo */
+/** @typedef {import("webpack").NormalModule} NormalModule */
+/** @typedef {import("./index.js").LoaderOptions} LoaderOptions */
+/** @typedef {{ [key: string]: string | function }} Locals */
+
+/** @typedef {any} TODO */
+
+/**
+ * @typedef {Object} Dependency
+ * @property {string} identifier
+ * @property {string | null} context
+ * @property {Buffer} content
+ * @property {string} media
+ * @property {string} [supports]
+ * @property {string} [layer]
+ * @property {Buffer} [sourceMap]
+ */
+
+/**
+ * @param {string} content
+ * @param {{ loaderContext: import("webpack").LoaderContext<LoaderOptions>, options: LoaderOptions, locals: Locals | undefined }} context
+ * @returns {string}
+ */
+function hotLoader(content, context) {
+  const accept = context.locals ? "" : "module.hot.accept(undefined, cssReload);";
+  return `${content}
+    if(module.hot) {
+      // ${Date.now()}
+      var cssReload = require(${stringifyRequest(context.loaderContext, path.join(__dirname, "hmr/hotModuleReplacement.js"))})(module.id, ${JSON.stringify({
+    ...context.options,
+    locals: !!context.locals
+  })});
+      module.hot.dispose(cssReload);
+      ${accept}
+    }
+  `;
+}
+
+/**
+ * @this {import("webpack").LoaderContext<LoaderOptions>}
+ * @param {string} request
+ */
+function pitch(request) {
+  // @ts-ignore
+  const options = this.getOptions( /** @type {Schema} */schema);
+  const emit = typeof options.emit !== "undefined" ? options.emit : true;
+  const callback = this.async();
+  const optionsFromPlugin = /** @type {TODO} */this[MiniCssExtractPlugin.pluginSymbol];
+  if (!optionsFromPlugin) {
+    callback(new Error("You forgot to add 'mini-css-extract-plugin' plugin (i.e. `{ plugins: [new MiniCssExtractPlugin()] }`), please read https://github.com/webpack-contrib/mini-css-extract-plugin#getting-started"));
+    return;
+  }
+  const {
+    webpack
+  } = /** @type {Compiler} */this._compiler;
+
+  /**
+   * @param {TODO} originalExports
+   * @param {Compilation} [compilation]
+   * @param {{ [name: string]: Source }} [assets]
+   * @param {Map<string, AssetInfo>} [assetsInfo]
+   * @returns {void}
+   */
+  const handleExports = (originalExports, compilation, assets, assetsInfo) => {
+    /** @type {Locals | undefined} */
+    let locals;
+    let namedExport;
+    const esModule = typeof options.esModule !== "undefined" ? options.esModule : true;
+
+    /**
+     * @param {Dependency[] | [null, object][]} dependencies
+     */
+    const addDependencies = dependencies => {
+      if (!Array.isArray(dependencies) && dependencies != null) {
+        throw new Error(`Exported value was not extracted as an array: ${JSON.stringify(dependencies)}`);
+      }
+      const identifierCountMap = new Map();
+      let lastDep;
+      for (const dependency of dependencies) {
+        if (! /** @type {Dependency} */dependency.identifier || !emit) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        const count = identifierCountMap.get( /** @type {Dependency} */dependency.identifier) || 0;
+        const CssDependency = MiniCssExtractPlugin.getCssDependency(webpack);
+
+        /** @type {NormalModule} */
+        this._module.addDependency(lastDep = new CssDependency( /** @type {Dependency} */
+        dependency, /** @type {Dependency} */
+        dependency.context, count));
+        identifierCountMap.set( /** @type {Dependency} */
+        dependency.identifier, count + 1);
+      }
+      if (lastDep && assets) {
+        lastDep.assets = assets;
+        lastDep.assetsInfo = assetsInfo;
+      }
+    };
+    try {
+      // eslint-disable-next-line no-underscore-dangle
+      const exports = originalExports.__esModule ? originalExports.default : originalExports;
+      namedExport =
+      // eslint-disable-next-line no-underscore-dangle
+      originalExports.__esModule && (!originalExports.default || !("locals" in originalExports.default));
+      if (namedExport) {
+        Object.keys(originalExports).forEach(key => {
+          if (key !== "default") {
+            if (!locals) {
+              locals = {};
+            }
+
+            /** @type {Locals} */
+            locals[key] = originalExports[key];
+          }
+        });
+      } else {
+        locals = exports && exports.locals;
+      }
+
+      /** @type {Dependency[] | [null, object][]} */
+      let dependencies;
+      if (!Array.isArray(exports)) {
+        dependencies = [[null, exports]];
+      } else {
+        dependencies = exports.map(([id, content, media, sourceMap, supports, layer]) => {
+          let identifier = id;
+          let context;
+          if (compilation) {
+            const module = /** @type {Module} */
+            findModuleById(compilation, id);
+            identifier = module.identifier();
+            ({
+              context
+            } = module);
+          } else {
+            // TODO check if this context is used somewhere
+            context = this.rootContext;
+          }
+          return {
+            identifier,
+            context,
+            content: Buffer.from(content),
+            media,
+            supports,
+            layer,
+            sourceMap: sourceMap ? Buffer.from(JSON.stringify(sourceMap)) :
+            // eslint-disable-next-line no-undefined
+            undefined
+          };
+        });
+      }
+      addDependencies(dependencies);
+    } catch (e) {
+      callback( /** @type {Error} */e);
+      return;
+    }
+    const result = locals ? namedExport ? Object.keys(locals).map(key => `\nexport var ${key} = ${stringifyLocal( /** @type {Locals} */locals[key])};`).join("") : `\n${esModule ? "export default" : "module.exports ="} ${JSON.stringify(locals)};` : esModule ? `\nexport {};` : "";
+    let resultSource = `// extracted by ${MiniCssExtractPlugin.pluginName}`;
+
+    // only attempt hotreloading if the css is actually used for something other than hash values
+    resultSource += this.hot && emit ? hotLoader(result, {
+      loaderContext: this,
+      options,
+      locals
+    }) : result;
+    callback(null, resultSource);
+  };
+  let {
+    publicPath
+  } = /** @type {Compilation} */
+  this._compilation.outputOptions;
+  if (typeof options.publicPath === "string") {
+    // eslint-disable-next-line prefer-destructuring
+    publicPath = options.publicPath;
+  } else if (typeof options.publicPath === "function") {
+    publicPath = options.publicPath(this.resourcePath, this.rootContext);
+  }
+  if (publicPath === "auto") {
+    publicPath = AUTO_PUBLIC_PATH;
+  }
+  if (typeof optionsFromPlugin.experimentalUseImportModule === "undefined" && typeof this.importModule === "function" || optionsFromPlugin.experimentalUseImportModule) {
+    if (!this.importModule) {
+      callback(new Error("You are using 'experimentalUseImportModule' but 'this.importModule' is not available in loader context. You need to have at least webpack 5.33.2."));
+      return;
+    }
+    let publicPathForExtract;
+    if (typeof publicPath === "string") {
+      const isAbsolutePublicPath = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(publicPath);
+      publicPathForExtract = isAbsolutePublicPath ? publicPath : `${ABSOLUTE_PUBLIC_PATH}${publicPath.replace(/\./g, SINGLE_DOT_PATH_SEGMENT)}`;
+    } else {
+      publicPathForExtract = publicPath;
+    }
+    this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!!!${request}`, {
+      layer: options.layer,
+      publicPath: /** @type {string} */publicPathForExtract,
+      baseUri: `${BASE_URI}/`
+    },
+    /**
+     * @param {Error | null | undefined} error
+     * @param {object} exports
+     */
+    (error, exports) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      handleExports(exports);
+    });
+    return;
+  }
+  const loaders = this.loaders.slice(this.loaderIndex + 1);
+  this.addDependency(this.resourcePath);
+  const childFilename = "*";
+  const outputOptions = {
+    filename: childFilename,
+    publicPath
+  };
+  const childCompiler = /** @type {Compilation} */
+  this._compilation.createChildCompiler(`${MiniCssExtractPlugin.pluginName} ${request}`, outputOptions);
+
+  // The templates are compiled and executed by NodeJS - similar to server side rendering
+  // Unfortunately this causes issues as some loaders require an absolute URL to support ES Modules
+  // The following config enables relative URL support for the child compiler
+  childCompiler.options.module = {
+    ...childCompiler.options.module
+  };
+  childCompiler.options.module.parser = {
+    ...childCompiler.options.module.parser
+  };
+  childCompiler.options.module.parser.javascript = {
+    ...childCompiler.options.module.parser.javascript,
+    url: "relative"
+  };
+  const {
+    NodeTemplatePlugin
+  } = webpack.node;
+  const {
+    NodeTargetPlugin
+  } = webpack.node;
+  new NodeTemplatePlugin(outputOptions).apply(childCompiler);
+  new NodeTargetPlugin().apply(childCompiler);
+  const {
+    EntryOptionPlugin
+  } = webpack;
+  const {
+    library: {
+      EnableLibraryPlugin
+    }
+  } = webpack;
+  new EnableLibraryPlugin("commonjs2").apply(childCompiler);
+  EntryOptionPlugin.applyEntryOption(childCompiler, this.context, {
+    child: {
+      library: {
+        type: "commonjs2"
+      },
+      import: [`!!${request}`]
+    }
+  });
+  const {
+    LimitChunkCountPlugin
+  } = webpack.optimize;
+  new LimitChunkCountPlugin({
+    maxChunks: 1
+  }).apply(childCompiler);
+  const {
+    NormalModule
+  } = webpack;
+  childCompiler.hooks.thisCompilation.tap(`${MiniCssExtractPlugin.pluginName} loader`,
+  /**
+   * @param {Compilation} compilation
+   */
+  compilation => {
+    const normalModuleHook = NormalModule.getCompilationHooks(compilation).loader;
+    normalModuleHook.tap(`${MiniCssExtractPlugin.pluginName} loader`, (loaderContext, module) => {
+      if (module.request === request) {
+        // eslint-disable-next-line no-param-reassign
+        module.loaders = loaders.map(loader => {
+          return {
+            type: null,
+            loader: loader.path,
+            options: loader.options,
+            ident: loader.ident
+          };
+        });
+      }
+    });
+  });
+
+  /** @type {string | Buffer} */
+  let source;
+  childCompiler.hooks.compilation.tap(MiniCssExtractPlugin.pluginName,
+  /**
+   * @param {Compilation} compilation
+   */
+  compilation => {
+    compilation.hooks.processAssets.tap(MiniCssExtractPlugin.pluginName, () => {
+      source = compilation.assets[childFilename] && compilation.assets[childFilename].source();
+
+      // Remove all chunk assets
+      compilation.chunks.forEach(chunk => {
+        chunk.files.forEach(file => {
+          compilation.deleteAsset(file);
+        });
+      });
+    });
+  });
+  childCompiler.runAsChild((error, entries, compilation) => {
+    if (error) {
+      callback(error);
+      return;
+    }
+    if ( /** @type {Compilation} */compilation.errors.length > 0) {
+      callback( /** @type {Compilation} */compilation.errors[0]);
+      return;
+    }
+
+    /** @type {{ [name: string]: Source }} */
+    const assets = Object.create(null);
+    /** @type {Map<string, AssetInfo>} */
+    const assetsInfo = new Map();
+    for (const asset of /** @type {Compilation} */compilation.getAssets()) {
+      assets[asset.name] = asset.source;
+      assetsInfo.set(asset.name, asset.info);
+    }
+
+    /** @type {Compilation} */
+    compilation.fileDependencies.forEach(dep => {
+      this.addDependency(dep);
+    }, this);
+
+    /** @type {Compilation} */
+    compilation.contextDependencies.forEach(dep => {
+      this.addContextDependency(dep);
+    }, this);
+    if (!source) {
+      callback(new Error("Didn't get a result from child compiler"));
+      return;
+    }
+    let originalExports;
+    try {
+      originalExports = evalModuleCode(this, source, request);
+    } catch (e) {
+      callback( /** @type {Error} */e);
+      return;
+    }
+    handleExports(originalExports, compilation, assets, assetsInfo);
+  });
+}
+module.exports = {
+  default: function loader() {},
+  pitch
+};

node_modules/mini-css-extract-plugin/dist/plugin-options.json

@@ -0,0 +1,79 @@
+{
+  "title": "Mini CSS Extract Plugin options",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "filename": {
+      "anyOf": [
+        {
+          "type": "string",
+          "absolutePath": false,
+          "minLength": 1
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "This option determines the name of each output CSS file.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#filename"
+    },
+    "chunkFilename": {
+      "anyOf": [
+        {
+          "type": "string",
+          "absolutePath": false,
+          "minLength": 1
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "This option determines the name of non-entry chunk files.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#chunkfilename"
+    },
+    "experimentalUseImportModule": {
+      "type": "boolean",
+      "description": "Enable the experimental importModule approach instead of using child compilers. This uses less memory and is faster.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#experimentaluseimportmodule"
+    },
+    "ignoreOrder": {
+      "type": "boolean",
+      "description": "Remove Order Warnings.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#ignoreorder"
+    },
+    "insert": {
+      "description": "Inserts the `link` tag at the given position for non-initial (async) (https://webpack.js.org/concepts/under-the-hood/#chunks) CSS chunks.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#insert",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "attributes": {
+      "description": "Adds custom attributes to the `link` tag for non-initial (async) (https://webpack.js.org/concepts/under-the-hood/#chunks) CSS chunks.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#attributes",
+      "type": "object"
+    },
+    "linkType": {
+      "anyOf": [
+        {
+          "enum": ["text/css"]
+        },
+        {
+          "type": "boolean"
+        }
+      ],
+      "description": "This option allows loading asynchronous chunks with a custom link type",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#linktype"
+    },
+    "runtime": {
+      "type": "boolean",
+      "description": "Enabled/Disables runtime generation. CSS will be still extracted and can be used for a custom loading methods.",
+      "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#noRuntime"
+    }
+  }
+}

node_modules/mini-css-extract-plugin/dist/utils.js

@@ -0,0 +1,198 @@
+"use strict";
+
+const NativeModule = require("module");
+const path = require("path");
+
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("webpack").Module} Module */
+/** @typedef {import("webpack").LoaderContext<any>} LoaderContext */
+
+/**
+ * @returns {boolean}
+ */
+function trueFn() {
+  return true;
+}
+
+/**
+ * @param {Compilation} compilation
+ * @param {string | number} id
+ * @returns {null | Module}
+ */
+function findModuleById(compilation, id) {
+  const {
+    modules,
+    chunkGraph
+  } = compilation;
+  for (const module of modules) {
+    const moduleId = typeof chunkGraph !== "undefined" ? chunkGraph.getModuleId(module) : module.id;
+    if (moduleId === id) {
+      return module;
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {LoaderContext} loaderContext
+ * @param {string | Buffer} code
+ * @param {string} filename
+ * @returns {object}
+ */
+function evalModuleCode(loaderContext, code, filename) {
+  // @ts-ignore
+  const module = new NativeModule(filename, loaderContext);
+
+  // @ts-ignore
+  module.paths = NativeModule._nodeModulePaths(loaderContext.context); // eslint-disable-line no-underscore-dangle
+  module.filename = filename;
+  // @ts-ignore
+  module._compile(code, filename); // eslint-disable-line no-underscore-dangle
+
+  return module.exports;
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {0 | 1 | -1}
+ */
+function compareIds(a, b) {
+  if (typeof a !== typeof b) {
+    return typeof a < typeof b ? -1 : 1;
+  }
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * @param {Module} a
+ * @param {Module} b
+ * @returns {0 | 1 | -1}
+ */
+function compareModulesByIdentifier(a, b) {
+  return compareIds(a.identifier(), b.identifier());
+}
+const MODULE_TYPE = "css/mini-extract";
+const AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__";
+const ABSOLUTE_PUBLIC_PATH = "webpack:///mini-css-extract-plugin/";
+const BASE_URI = "webpack://";
+const SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+function isAbsolutePath(str) {
+  return path.posix.isAbsolute(str) || path.win32.isAbsolute(str);
+}
+const RELATIVE_PATH_REGEXP = /^\.\.?[/\\]/;
+
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+function isRelativePath(str) {
+  return RELATIVE_PATH_REGEXP.test(str);
+}
+
+// TODO simplify for the next major release
+/**
+ * @param {LoaderContext} loaderContext
+ * @param {string} request
+ * @returns {string}
+ */
+function stringifyRequest(loaderContext, request) {
+  if (typeof loaderContext.utils !== "undefined" && typeof loaderContext.utils.contextify === "function") {
+    return JSON.stringify(loaderContext.utils.contextify(loaderContext.context || loaderContext.rootContext, request));
+  }
+  const splitted = request.split("!");
+  const {
+    context
+  } = loaderContext;
+  return JSON.stringify(splitted.map(part => {
+    // First, separate singlePath from query, because the query might contain paths again
+    const splittedPart = part.match(/^(.*?)(\?.*)/);
+    const query = splittedPart ? splittedPart[2] : "";
+    let singlePath = splittedPart ? splittedPart[1] : part;
+    if (isAbsolutePath(singlePath) && context) {
+      singlePath = path.relative(context, singlePath);
+      if (isAbsolutePath(singlePath)) {
+        // If singlePath still matches an absolute path, singlePath was on a different drive than context.
+        // In this case, we leave the path platform-specific without replacing any separators.
+        // @see https://github.com/webpack/loader-utils/pull/14
+        return singlePath + query;
+      }
+      if (isRelativePath(singlePath) === false) {
+        // Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
+        singlePath = `./${singlePath}`;
+      }
+    }
+    return singlePath.replace(/\\/g, "/") + query;
+  }).join("!"));
+}
+
+/**
+ * @param {string} filename
+ * @param {string} outputPath
+ * @param {boolean} enforceRelative
+ * @returns {string}
+ */
+function getUndoPath(filename, outputPath, enforceRelative) {
+  let depth = -1;
+  let append = "";
+
+  // eslint-disable-next-line no-param-reassign
+  outputPath = outputPath.replace(/[\\/]$/, "");
+  for (const part of filename.split(/[/\\]+/)) {
+    if (part === "..") {
+      if (depth > -1) {
+        // eslint-disable-next-line no-plusplus
+        depth--;
+      } else {
+        const i = outputPath.lastIndexOf("/");
+        const j = outputPath.lastIndexOf("\\");
+        const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+        if (pos < 0) {
+          return `${outputPath}/`;
+        }
+        append = `${outputPath.slice(pos + 1)}/${append}`;
+
+        // eslint-disable-next-line no-param-reassign
+        outputPath = outputPath.slice(0, pos);
+      }
+    } else if (part !== ".") {
+      // eslint-disable-next-line no-plusplus
+      depth++;
+    }
+  }
+  return depth > 0 ? `${"../".repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
+}
+
+/**
+ *
+ * @param {string | function} value
+ * @returns {string}
+ */
+function stringifyLocal(value) {
+  return typeof value === "function" ? value.toString() : JSON.stringify(value);
+}
+module.exports = {
+  trueFn,
+  findModuleById,
+  evalModuleCode,
+  compareModulesByIdentifier,
+  MODULE_TYPE,
+  AUTO_PUBLIC_PATH,
+  ABSOLUTE_PUBLIC_PATH,
+  BASE_URI,
+  SINGLE_DOT_PATH_SEGMENT,
+  stringifyRequest,
+  stringifyLocal,
+  getUndoPath
+};

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 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/mini-css-extract-plugin/node_modules/ajv-keywords/README.md

@@ -0,0 +1,745 @@
+# ajv-keywords
+
+Custom JSON-Schema keywords for [Ajv](https://github.com/epoberezkin/ajv) validator
+
+[![build](https://github.com/ajv-validator/ajv-keywords/workflows/build/badge.svg)](https://github.com/ajv-validator/ajv-keywords/actions?query=workflow%3Abuild)
+[![npm](https://img.shields.io/npm/v/ajv-keywords.svg)](https://www.npmjs.com/package/ajv-keywords)
+[![npm downloads](https://img.shields.io/npm/dm/ajv-keywords.svg)](https://www.npmjs.com/package/ajv-keywords)
+[![coverage](https://coveralls.io/repos/github/ajv-validator/ajv-keywords/badge.svg?branch=master)](https://coveralls.io/github/ajv-validator/ajv-keywords?branch=master)
+[![gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv)
+
+**Please note**: This readme file is for [ajv-keywords v5.0.0](https://github.com/ajv-validator/ajv-keywords/releases/tag/v5.0.0) that should be used with [ajv v8](https://github.com/ajv-validator/ajv).
+
+[ajv-keywords v3](https://github.com/ajv-validator/ajv-keywords/tree/v3) should be used with [ajv v6](https://github.com/ajv-validator/ajv/tree/v6).
+
+## Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Keywords](#keywords)
+  - [Types](#types)
+    - [typeof](#typeof)
+    - [instanceof](#instanceof)<sup>\+</sup>
+  - [Keywords for numbers](#keywords-for-numbers)
+    - [range and exclusiveRange](#range-and-exclusiverange)
+  - [Keywords for strings](#keywords-for-strings)
+    - [regexp](#regexp)
+    - [transform](#transform)<sup>\*</sup>
+  - [Keywords for arrays](#keywords-for-arrays)
+    - [uniqueItemProperties](#uniqueitemproperties)<sup>\+</sup>
+  - [Keywords for objects](#keywords-for-objects)
+    - [allRequired](#allrequired)
+    - [anyRequired](#anyrequired)
+    - [oneRequired](#onerequired)
+    - [patternRequired](#patternrequired)
+    - [prohibited](#prohibited)
+    - [deepProperties](#deepproperties)
+    - [deepRequired](#deeprequired)
+    - [dynamicDefaults](#dynamicdefaults)<sup>\*</sup><sup>\+</sup>
+  - [Keywords for all types](#keywords-for-all-types)
+    - [select/selectCases/selectDefault](#selectselectcasesselectdefault)
+- [Security contact](#security-contact)
+- [Open-source software support](#open-source-software-support)
+- [License](#license)
+
+<sup>\*</sup> - keywords that modify data
+<sup>\+</sup> - keywords that are not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md)
+
+## Install
+
+To install version 4 to use with [Ajv v7](https://github.com/ajv-validator/ajv):
+
+```
+npm install ajv-keywords
+```
+
+## Usage
+
+To add all available keywords:
+
+```javascript
+const Ajv = require("ajv")
+const ajv = new Ajv()
+require("ajv-keywords")(ajv)
+
+ajv.validate({instanceof: "RegExp"}, /.*/) // true
+ajv.validate({instanceof: "RegExp"}, ".*") // false
+```
+
+To add a single keyword:
+
+```javascript
+require("ajv-keywords")(ajv, "instanceof")
+```
+
+To add multiple keywords:
+
+```javascript
+require("ajv-keywords")(ajv, ["typeof", "instanceof"])
+```
+
+To add a single keyword directly (to avoid adding unused code):
+
+```javascript
+require("ajv-keywords/dist/keywords/select")(ajv, opts)
+```
+
+To add all keywords via Ajv options:
+
+```javascript
+const ajv = new Ajv({keywords: require("ajv-keywords/dist/definitions")(opts)})
+```
+
+To add one or several keywords via options:
+
+```javascript
+const ajv = new Ajv({
+  keywords: [
+    require("ajv-keywords/dist/definitions/typeof")(),
+    require("ajv-keywords/dist/definitions/instanceof")(),
+    // select exports an array of 3 definitions - see "select" in docs
+    ...require("ajv-keywords/dist/definitions/select")(opts),
+  ],
+})
+```
+
+`opts` is an optional object with a property `defaultMeta` - URI of meta-schema to use for keywords that use subschemas (`select` and `deepProperties`). The default is `"http://json-schema.org/schema"`.
+
+## Keywords
+
+### Types
+
+#### `typeof`
+
+Based on JavaScript `typeof` operation.
+
+The value of the keyword should be a string (`"undefined"`, `"string"`, `"number"`, `"object"`, `"function"`, `"boolean"` or `"symbol"`) or an array of strings.
+
+To pass validation the result of `typeof` operation on the value should be equal to the string (or one of the strings in the array).
+
+```javascript
+ajv.validate({typeof: "undefined"}, undefined) // true
+ajv.validate({typeof: "undefined"}, null) // false
+ajv.validate({typeof: ["undefined", "object"]}, null) // true
+```
+
+#### `instanceof`
+
+Based on JavaScript `instanceof` operation.
+
+The value of the keyword should be a string (`"Object"`, `"Array"`, `"Function"`, `"Number"`, `"String"`, `"Date"`, `"RegExp"` or `"Promise"`) or an array of strings.
+
+To pass validation the result of `data instanceof ...` operation on the value should be true:
+
+```javascript
+ajv.validate({instanceof: "Array"}, []) // true
+ajv.validate({instanceof: "Array"}, {}) // false
+ajv.validate({instanceof: ["Array", "Function"]}, function () {}) // true
+```
+
+You can add your own constructor function to be recognised by this keyword:
+
+```javascript
+class MyClass {}
+const instanceofDef = require("ajv-keywords/dist/definitions/instanceof")
+instanceofDef.CONSTRUCTORS.MyClass = MyClass
+ajv.validate({instanceof: "MyClass"}, new MyClass()) // true
+```
+
+**Please note**: currently `instanceof` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md) - it has to be implemented as [`code` keyword](https://github.com/ajv-validator/ajv/blob/master/docs/keywords.md#define-keyword-with-code-generation-function) to support it (PR is welcome).
+
+### Keywords for numbers
+
+#### `range` and `exclusiveRange`
+
+Syntax sugar for the combination of minimum and maximum keywords (or exclusiveMinimum and exclusiveMaximum), also fails schema compilation if there are no numbers in the range.
+
+The value of these keywords must be an array consisting of two numbers, the second must be greater or equal than the first one.
+
+If the validated value is not a number the validation passes, otherwise to pass validation the value should be greater (or equal) than the first number and smaller (or equal) than the second number in the array.
+
+```javascript
+const schema = {type: "number", range: [1, 3]}
+ajv.validate(schema, 1) // true
+ajv.validate(schema, 2) // true
+ajv.validate(schema, 3) // true
+ajv.validate(schema, 0.99) // false
+ajv.validate(schema, 3.01) // false
+
+const schema = {type: "number", exclusiveRange: [1, 3]}
+ajv.validate(schema, 1.01) // true
+ajv.validate(schema, 2) // true
+ajv.validate(schema, 2.99) // true
+ajv.validate(schema, 1) // false
+ajv.validate(schema, 3) // false
+```
+
+### Keywords for strings
+
+#### `regexp`
+
+This keyword allows to use regular expressions with flags in schemas, and also without `"u"` flag when needed (the standard `pattern` keyword does not support flags and implies the presence of `"u"` flag).
+
+This keyword applies only to strings. If the data is not a string, the validation succeeds.
+
+The value of this keyword can be either a string (the result of `regexp.toString()`) or an object with the properties `pattern` and `flags` (the same strings that should be passed to RegExp constructor).
+
+```javascript
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "string", regexp: "/foo/i"},
+    bar: {type: "string", regexp: {pattern: "bar", flags: "i"}},
+  },
+}
+
+const validData = {
+  foo: "Food",
+  bar: "Barmen",
+}
+
+const invalidData = {
+  foo: "fog",
+  bar: "bad",
+}
+```
+
+#### `transform`
+
+This keyword allows a string to be modified during validation.
+
+This keyword applies only to strings. If the data is not a string, the `transform` keyword is ignored.
+
+A standalone string cannot be modified, i.e. `data = 'a'; ajv.validate(schema, data);`, because strings are passed by value
+
+**Supported transformations:**
+
+- `trim`: remove whitespace from start and end
+- `trimStart`/`trimLeft`: remove whitespace from start
+- `trimEnd`/`trimRight`: remove whitespace from end
+- `toLowerCase`: convert to lower case
+- `toUpperCase`: convert to upper case
+- `toEnumCase`: change string case to be equal to one of `enum` values in the schema
+
+Transformations are applied in the order they are listed.
+
+Note: `toEnumCase` requires that all allowed values are unique when case insensitive.
+
+**Example: multiple transformations**
+
+```javascript
+require("ajv-keywords")(ajv, "transform")
+
+const schema = {
+  type: "array",
+  items: {
+    type: "string",
+    transform: ["trim", "toLowerCase"],
+  },
+}
+
+const data = ["  MixCase  "]
+ajv.validate(schema, data)
+console.log(data) // ['mixcase']
+```
+
+**Example: `enumcase`**
+
+```javascript
+require("ajv-keywords")(ajv, ["transform"])
+
+const schema = {
+  type: "array",
+  items: {
+    type: "string",
+    transform: ["trim", "toEnumCase"],
+    enum: ["pH"],
+  },
+}
+
+const data = ["ph", " Ph", "PH", "pH "]
+ajv.validate(schema, data)
+console.log(data) // ['pH','pH','pH','pH']
+```
+
+### Keywords for arrays
+
+#### `uniqueItemProperties`
+
+The keyword allows to check that some properties in array items are unique.
+
+This keyword applies only to arrays. If the data is not an array, the validation succeeds.
+
+The value of this keyword must be an array of strings - property names that should have unique values across all items.
+
+```javascript
+const schema = {
+  type: "array",
+  uniqueItemProperties: ["id", "name"],
+}
+
+const validData = [{id: 1}, {id: 2}, {id: 3}]
+
+const invalidData1 = [
+  {id: 1},
+  {id: 1}, // duplicate "id"
+  {id: 3},
+]
+
+const invalidData2 = [
+  {id: 1, name: "taco"},
+  {id: 2, name: "taco"}, // duplicate "name"
+  {id: 3, name: "salsa"},
+]
+```
+
+This keyword is contributed by [@blainesch](https://github.com/blainesch).
+
+**Please note**: currently `uniqueItemProperties` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md) - it has to be implemented as [`code` keyword](https://github.com/ajv-validator/ajv/blob/master/docs/keywords.md#define-keyword-with-code-generation-function) to support it (PR is welcome).
+
+### Keywords for objects
+
+#### `allRequired`
+
+This keyword allows to require the presence of all properties used in `properties` keyword in the same schema object.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be boolean.
+
+If the value of the keyword is `false`, the validation succeeds.
+
+If the value of the keyword is `true`, the validation succeeds if the data contains all properties defined in `properties` keyword (in the same schema object).
+
+If the `properties` keyword is not present in the same schema object, schema compilation will throw exception.
+
+```javascript
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "number"},
+    bar: {type: "number"},
+  },
+  allRequired: true,
+}
+
+const validData = {foo: 1, bar: 2}
+const alsoValidData = {foo: 1, bar: 2, baz: 3}
+
+const invalidDataList = [{}, {foo: 1}, {bar: 2}]
+```
+
+#### `anyRequired`
+
+This keyword allows to require the presence of any (at least one) property from the list.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be an array of strings, each string being a property name. For data object to be valid at least one of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  anyRequired: ["foo", "bar"],
+}
+
+const validData = {foo: 1}
+const alsoValidData = {foo: 1, bar: 2}
+
+const invalidDataList = [{}, {baz: 3}]
+```
+
+#### `oneRequired`
+
+This keyword allows to require the presence of only one property from the list.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be an array of strings, each string being a property name. For data object to be valid exactly one of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  oneRequired: ["foo", "bar"],
+}
+
+const validData = {foo: 1}
+const alsoValidData = {bar: 2, baz: 3}
+
+const invalidDataList = [{}, {baz: 3}, {foo: 1, bar: 2}]
+```
+
+#### `patternRequired`
+
+This keyword allows to require the presence of properties that match some pattern(s).
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword should be an array of strings, each string being a regular expression. For data object to be valid each regular expression in this array should match at least one property name in the data object.
+
+If the array contains multiple regular expressions, more than one expression can match the same property name.
+
+```javascript
+const schema = {
+  type: "object",
+  patternRequired: ["f.*o", "b.*r"],
+}
+
+const validData = {foo: 1, bar: 2}
+const alsoValidData = {foobar: 3}
+
+const invalidDataList = [{}, {foo: 1}, {bar: 2}]
+```
+
+#### `prohibited`
+
+This keyword allows to prohibit that any of the properties in the list is present in the object.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword should be an array of strings, each string being a property name. For data object to be valid none of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  prohibited: ["foo", "bar"],
+}
+
+const validData = {baz: 1}
+const alsoValidData = {}
+
+const invalidDataList = [{foo: 1}, {bar: 2}, {foo: 1, bar: 2}]
+```
+
+**Please note**: `{prohibited: ['foo', 'bar']}` is equivalent to `{not: {anyRequired: ['foo', 'bar']}}` (i.e. it has the same validation result for any data).
+
+#### `deepProperties`
+
+This keyword allows to validate deep properties (identified by JSON pointers).
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value should be an object, where keys are JSON pointers to the data, starting from the current position in data, and the values are JSON schemas. For data object to be valid the value of each JSON pointer should be valid according to the corresponding schema.
+
+```javascript
+const schema = {
+  type: "object",
+  deepProperties: {
+    "/users/1/role": {enum: ["admin"]},
+  },
+}
+
+const validData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "admin",
+    },
+  ],
+}
+
+const alsoValidData = {
+  users: {
+    1: {
+      id: 123,
+      role: "admin",
+    },
+  },
+}
+
+const invalidData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "user",
+    },
+  ],
+}
+
+const alsoInvalidData = {
+  users: {
+    1: {
+      id: 123,
+      role: "user",
+    },
+  },
+}
+```
+
+#### `deepRequired`
+
+This keyword allows to check that some deep properties (identified by JSON pointers) are available.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value should be an array of JSON pointers to the data, starting from the current position in data. For data object to be valid each JSON pointer should be some existing part of the data.
+
+```javascript
+const schema = {
+  type: "object",
+  deepRequired: ["/users/1/role"],
+}
+
+const validData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "admin",
+    },
+  ],
+}
+
+const invalidData = {
+  users: [
+    {},
+    {
+      id: 123,
+    },
+  ],
+}
+```
+
+See [json-schema-org/json-schema-spec#203](https://github.com/json-schema-org/json-schema-spec/issues/203#issue-197211916) for an example of the equivalent schema without `deepRequired` keyword.
+
+### Keywords for all types
+
+#### `select`/`selectCases`/`selectDefault`
+
+**Please note**: these keywords are deprecated. It is recommended to use OpenAPI [discriminator](https://ajv.js.org/json-schema.html#discriminator) keyword supported by Ajv v8 instead of `select`.
+
+These keywords allow to choose the schema to validate the data based on the value of some property in the validated data.
+
+These keywords must be present in the same schema object (`selectDefault` is optional).
+
+The value of `select` keyword should be a [\$data reference](https://github.com/ajv-validator/ajv/blob/master/docs/validation.md#data-reference) that points to any primitive JSON type (string, number, boolean or null) in the data that is validated. You can also use a constant of primitive type as the value of this keyword (e.g., for debugging purposes).
+
+The value of `selectCases` keyword must be an object where each property name is a possible string representation of the value of `select` keyword and each property value is a corresponding schema (from draft-06 it can be boolean) that must be used to validate the data.
+
+The value of `selectDefault` keyword is a schema (also can be boolean) that must be used to validate the data in case `selectCases` has no key equal to the stringified value of `select` keyword.
+
+The validation succeeds in one of the following cases:
+
+- the validation of data using selected schema succeeds,
+- none of the schemas is selected for validation,
+- the value of select is undefined (no property in the data that the data reference points to).
+
+If `select` value (in data) is not a primitive type the validation fails.
+
+This keyword correctly tracks evaluated properties and items to work with `unevaluatedProperties` and `unevaluatedItems` keywords - only properties and items from the subschema that was used (one of `selectCases` subschemas or `selectDefault` subschema) are marked as evaluated.
+
+**Please note**: these keywords require Ajv `$data` option to support [\$data reference](https://github.com/ajv-validator/ajv/blob/master/docs/validation.md#data-reference).
+
+```javascript
+require("ajv-keywords")(ajv, "select")
+
+const schema = {
+  type: "object",
+  required: ["kind"],
+  properties: {
+    kind: {type: "string"},
+  },
+  select: {$data: "0/kind"},
+  selectCases: {
+    foo: {
+      required: ["foo"],
+      properties: {
+        kind: {},
+        foo: {type: "string"},
+      },
+      additionalProperties: false,
+    },
+    bar: {
+      required: ["bar"],
+      properties: {
+        kind: {},
+        bar: {type: "number"},
+      },
+      additionalProperties: false,
+    },
+  },
+  selectDefault: {
+    propertyNames: {
+      not: {enum: ["foo", "bar"]},
+    },
+  },
+}
+
+const validDataList = [
+  {kind: "foo", foo: "any"},
+  {kind: "bar", bar: 1},
+  {kind: "anything_else", not_bar_or_foo: "any value"},
+]
+
+const invalidDataList = [
+  {kind: "foo"}, // no property foo
+  {kind: "bar"}, // no property bar
+  {kind: "foo", foo: "any", another: "any value"}, // additional property
+  {kind: "bar", bar: 1, another: "any value"}, // additional property
+  {kind: "anything_else", foo: "any"}, // property foo not allowed
+  {kind: "anything_else", bar: 1}, // property bar not allowed
+]
+```
+
+#### `dynamicDefaults`
+
+This keyword allows to assign dynamic defaults to properties, such as timestamps, unique IDs etc.
+
+This keyword only works if `useDefaults` options is used and not inside `anyOf` keywords etc., in the same way as [default keyword treated by Ajv](https://github.com/epoberezkin/ajv#assigning-defaults).
+
+The keyword should be added on the object level. Its value should be an object with each property corresponding to a property name, in the same way as in standard `properties` keyword. The value of each property can be:
+
+- an identifier of dynamic default function (a string)
+- an object with properties `func` (an identifier) and `args` (an object with parameters that will be passed to this function during schema compilation - see examples).
+
+The properties used in `dynamicDefaults` should not be added to `required` keyword in the same schema (or validation will fail), because unlike `default` this keyword is processed after validation.
+
+There are several predefined dynamic default functions:
+
+- `"timestamp"` - current timestamp in milliseconds
+- `"datetime"` - current date and time as string (ISO, valid according to `date-time` format)
+- `"date"` - current date as string (ISO, valid according to `date` format)
+- `"time"` - current time as string (ISO, valid according to `time` format)
+- `"random"` - pseudo-random number in [0, 1) interval
+- `"randomint"` - pseudo-random integer number. If string is used as a property value, the function will randomly return 0 or 1. If object `{ func: 'randomint', args: { max: N } }` is used then the default will be an integer number in [0, N) interval.
+- `"seq"` - sequential integer number starting from 0. If string is used as a property value, the default sequence will be used. If object `{ func: 'seq', args: { name: 'foo'} }` is used then the sequence with name `"foo"` will be used. Sequences are global, even if different ajv instances are used.
+
+```javascript
+const schema = {
+  type: "object",
+  dynamicDefaults: {
+    ts: "datetime",
+    r: {func: "randomint", args: {max: 100}},
+    id: {func: "seq", args: {name: "id"}},
+  },
+  properties: {
+    ts: {
+      type: "string",
+      format: "date-time",
+    },
+    r: {
+      type: "integer",
+      minimum: 0,
+      exclusiveMaximum: 100,
+    },
+    id: {
+      type: "integer",
+      minimum: 0,
+    },
+  },
+}
+
+const data = {}
+ajv.validate(data) // true
+data // { ts: '2016-12-01T22:07:28.829Z', r: 25, id: 0 }
+
+const data1 = {}
+ajv.validate(data1) // true
+data1 // { ts: '2016-12-01T22:07:29.832Z', r: 68, id: 1 }
+
+ajv.validate(data1) // true
+data1 // didn't change, as all properties were defined
+```
+
+When using the `useDefaults` option value `"empty"`, properties and items equal to `null` or `""` (empty string) will be considered missing and assigned defaults. Use `allOf` [compound keyword](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#compound-keywords) to execute `dynamicDefaults` before validation.
+
+```javascript
+const schema = {
+  type: "object",
+  allOf: [
+    {
+      dynamicDefaults: {
+        ts: "datetime",
+        r: {func: "randomint", args: {min: 5, max: 100}},
+        id: {func: "seq", args: {name: "id"}},
+      },
+    },
+    {
+      properties: {
+        ts: {
+          type: "string",
+        },
+        r: {
+          type: "number",
+          minimum: 5,
+          exclusiveMaximum: 100,
+        },
+        id: {
+          type: "integer",
+          minimum: 0,
+        },
+      },
+    },
+  ],
+}
+
+const data = {ts: "", r: null}
+ajv.validate(data) // true
+data // { ts: '2016-12-01T22:07:28.829Z', r: 25, id: 0 }
+```
+
+You can add your own dynamic default function to be recognised by this keyword:
+
+```javascript
+const uuid = require("uuid")
+
+const def = require("ajv-keywords/dist/definitions/dynamicDefaults")
+def.DEFAULTS.uuid = () => uuid.v4
+
+const schema = {
+  dynamicDefaults: {id: "uuid"},
+  properties: {id: {type: "string", format: "uuid"}},
+}
+
+const data = {}
+ajv.validate(schema, data) // true
+data // { id: 'a1183fbe-697b-4030-9bcc-cfeb282a9150' };
+
+const data1 = {}
+ajv.validate(schema, data1) // true
+data1 // { id: '5b008de7-1669-467a-a5c6-70fa244d7209' }
+```
+
+You also can define dynamic default that accept parameters, e.g. version of uuid:
+
+```javascript
+const uuid = require("uuid")
+
+function getUuid(args) {
+  const version = "v" + ((arvs && args.v) || "4")
+  return uuid[version]
+}
+
+const def = require("ajv-keywords/dist/definitions/dynamicDefaults")
+def.DEFAULTS.uuid = getUuid
+
+const schema = {
+  dynamicDefaults: {
+    id1: "uuid", // v4
+    id2: {func: "uuid", v: 4}, // v4
+    id3: {func: "uuid", v: 1}, // v1
+  },
+}
+```
+
+**Please note**: dynamic default functions are differentiated by the number of parameters they have (`function.length`). Functions that do not expect default must have one non-optional argument so that `function.length` > 0.
+
+`dynamicDefaults` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md).
+
+## 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-keywords is a part of [Tidelift subscription](https://tidelift.com/subscription/pkg/npm-ajv-keywords?utm_source=npm-ajv-keywords&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](https://github.com/epoberezkin/ajv-keywords/blob/master/LICENSE)

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_range.d.ts

@@ -0,0 +1,5 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare type RangeKwd = "range" | "exclusiveRange";
+export default function getRangeDef(keyword: RangeKwd): GetDefinition<MacroKeywordDefinition>;
+export {};

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_range.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRangeDef(keyword) {
+    return () => ({
+        keyword,
+        type: "number",
+        schemaType: "array",
+        macro: function ([min, max]) {
+            validateRangeSchema(min, max);
+            return keyword === "range"
+                ? { minimum: min, maximum: max }
+                : { exclusiveMinimum: min, exclusiveMaximum: max };
+        },
+        metaSchema: {
+            type: "array",
+            minItems: 2,
+            maxItems: 2,
+            items: { type: "number" },
+        },
+    });
+    function validateRangeSchema(min, max) {
+        if (min > max || (keyword === "exclusiveRange" && min === max)) {
+            throw new Error("There are no numbers in range");
+        }
+    }
+}
+exports.default = getRangeDef;
+//# sourceMappingURL=_range.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_range.js","sourceRoot":"","sources":["../../src/definitions/_range.ts"],"names":[],"mappings":";;AAKA,SAAwB,WAAW,CAAC,OAAiB;IACnD,OAAO,GAAG,EAAE,CAAC,CAAC;QACZ,OAAO;QACP,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAmB;YAC3C,mBAAmB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YAC7B,OAAO,OAAO,KAAK,OAAO;gBACxB,CAAC,CAAC,EAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAC;gBAC9B,CAAC,CAAC,EAAC,gBAAgB,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAC,CAAA;QACpD,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAC,CAAA;IAEF,SAAS,mBAAmB,CAAC,GAAW,EAAE,GAAW;QACnD,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,KAAK,gBAAgB,IAAI,GAAG,KAAK,GAAG,CAAC,EAAE;YAC9D,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAA;SACjD;IACH,CAAC;AACH,CAAC;AAxBD,8BAwBC"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_required.d.ts

@@ -0,0 +1,5 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare type RequiredKwd = "anyRequired" | "oneRequired";
+export default function getRequiredDef(keyword: RequiredKwd): GetDefinition<MacroKeywordDefinition>;
+export {};

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_required.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRequiredDef(keyword) {
+    return () => ({
+        keyword,
+        type: "object",
+        schemaType: "array",
+        macro(schema) {
+            if (schema.length === 0)
+                return true;
+            if (schema.length === 1)
+                return { required: schema };
+            const comb = keyword === "anyRequired" ? "anyOf" : "oneOf";
+            return { [comb]: schema.map((p) => ({ required: [p] })) };
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string" },
+        },
+    });
+}
+exports.default = getRequiredDef;
+//# sourceMappingURL=_required.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_required.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_required.js","sourceRoot":"","sources":["../../src/definitions/_required.ts"],"names":[],"mappings":";;AAKA,SAAwB,cAAc,CACpC,OAAoB;IAEpB,OAAO,GAAG,EAAE,CAAC,CAAC;QACZ,OAAO;QACP,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK,CAAC,MAAgB;YACpB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAA;YACpC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAC,CAAA;YAClD,MAAM,IAAI,GAAG,OAAO,KAAK,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAA;YAC1D,OAAO,EAAC,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAC,CAAA;QACvD,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAC,CAAA;AACJ,CAAC;AAlBD,iCAkBC"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_types.d.ts

@@ -0,0 +1,5 @@
+import type { KeywordDefinition } from "ajv";
+export interface DefinitionOptions {
+    defaultMeta?: string | boolean;
+}
+export declare type GetDefinition<T extends KeywordDefinition> = (opts?: DefinitionOptions) => T;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=_types.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.js","sourceRoot":"","sources":["../../src/definitions/_types.ts"],"names":[],"mappings":""}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_util.d.ts

@@ -0,0 +1,4 @@
+import type { DefinitionOptions } from "./_types";
+import type { SchemaObject, KeywordCxt, Name } from "ajv";
+export declare function metaSchemaRef({ defaultMeta }?: DefinitionOptions): SchemaObject;
+export declare function usePattern({ gen, it: { opts } }: KeywordCxt, pattern: string, flags?: string): Name;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePattern = exports.metaSchemaRef = void 0;
+const codegen_1 = require("ajv/dist/compile/codegen");
+const META_SCHEMA_ID = "http://json-schema.org/schema";
+function metaSchemaRef({ defaultMeta } = {}) {
+    return defaultMeta === false ? {} : { $ref: defaultMeta || META_SCHEMA_ID };
+}
+exports.metaSchemaRef = metaSchemaRef;
+function usePattern({ gen, it: { opts } }, pattern, flags = opts.unicodeRegExp ? "u" : "") {
+    const rx = new RegExp(pattern, flags);
+    return gen.scopeValue("pattern", {
+        key: rx.toString(),
+        ref: rx,
+        code: (0, codegen_1._) `new RegExp(${pattern}, ${flags})`,
+    });
+}
+exports.usePattern = usePattern;
+//# sourceMappingURL=_util.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/_util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.js","sourceRoot":"","sources":["../../src/definitions/_util.ts"],"names":[],"mappings":";;;AAEA,sDAA0C;AAE1C,MAAM,cAAc,GAAG,+BAA+B,CAAA;AAEtD,SAAgB,aAAa,CAAC,EAAC,WAAW,KAAuB,EAAE;IACjE,OAAO,WAAW,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,IAAI,EAAE,WAAW,IAAI,cAAc,EAAC,CAAA;AAC3E,CAAC;AAFD,sCAEC;AAED,SAAgB,UAAU,CACxB,EAAC,GAAG,EAAE,EAAE,EAAE,EAAC,IAAI,EAAC,EAAa,EAC7B,OAAe,EACf,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;IAErC,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IACrC,OAAO,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE;QAC/B,GAAG,EAAE,EAAE,CAAC,QAAQ,EAAE;QAClB,GAAG,EAAE,EAAE;QACP,IAAI,EAAE,IAAA,WAAC,EAAA,cAAc,OAAO,KAAK,KAAK,GAAG;KAC1C,CAAC,CAAA;AACJ,CAAC;AAXD,gCAWC"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/allRequired.d.ts

@@ -0,0 +1,2 @@
+import type { MacroKeywordDefinition } from "ajv";
+export default function getDef(): MacroKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/allRequired.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDef() {
+    return {
+        keyword: "allRequired",
+        type: "object",
+        schemaType: "boolean",
+        macro(schema, parentSchema) {
+            if (!schema)
+                return true;
+            const required = Object.keys(parentSchema.properties);
+            if (required.length === 0)
+                return true;
+            return { required };
+        },
+        dependencies: ["properties"],
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=allRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/allRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allRequired.js","sourceRoot":"","sources":["../../src/definitions/allRequired.ts"],"names":[],"mappings":";;AAEA,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,SAAS;QACrB,KAAK,CAAC,MAAe,EAAE,YAAY;YACjC,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAA;YACxB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAA;YACrD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAA;YACtC,OAAO,EAAC,QAAQ,EAAC,CAAA;QACnB,CAAC;QACD,YAAY,EAAE,CAAC,YAAY,CAAC;KAC7B,CAAA;AACH,CAAC;AAbD,yBAaC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/anyRequired.d.ts

@@ -0,0 +1,4 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare const getDef: GetDefinition<MacroKeywordDefinition>;
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/anyRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _required_1 = __importDefault(require("./_required"));
+const getDef = (0, _required_1.default)("anyRequired");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=anyRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/anyRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyRequired.js","sourceRoot":"","sources":["../../src/definitions/anyRequired.ts"],"names":[],"mappings":";;;;;AAEA,4DAAwC;AAExC,MAAM,MAAM,GAA0C,IAAA,mBAAc,EAAC,aAAa,CAAC,CAAA;AAEnF,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepProperties.d.ts

@@ -0,0 +1,3 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { DefinitionOptions } from "./_types";
+export default function getDef(opts?: DefinitionOptions): MacroKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepProperties.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _util_1 = require("./_util");
+function getDef(opts) {
+    return {
+        keyword: "deepProperties",
+        type: "object",
+        schemaType: "object",
+        macro: function (schema) {
+            const allOf = [];
+            for (const pointer in schema)
+                allOf.push(getSchema(pointer, schema[pointer]));
+            return { allOf };
+        },
+        metaSchema: {
+            type: "object",
+            propertyNames: { type: "string", format: "json-pointer" },
+            additionalProperties: (0, _util_1.metaSchemaRef)(opts),
+        },
+    };
+}
+exports.default = getDef;
+function getSchema(jsonPointer, schema) {
+    const segments = jsonPointer.split("/");
+    const rootSchema = {};
+    let pointerSchema = rootSchema;
+    for (let i = 1; i < segments.length; i++) {
+        let segment = segments[i];
+        const isLast = i === segments.length - 1;
+        segment = unescapeJsonPointer(segment);
+        const properties = (pointerSchema.properties = {});
+        let items;
+        if (/[0-9]+/.test(segment)) {
+            let count = +segment;
+            items = pointerSchema.items = [];
+            pointerSchema.type = ["object", "array"];
+            while (count--)
+                items.push({});
+        }
+        else {
+            pointerSchema.type = "object";
+        }
+        pointerSchema = isLast ? schema : {};
+        properties[segment] = pointerSchema;
+        if (items)
+            items.push(pointerSchema);
+    }
+    return rootSchema;
+}
+function unescapeJsonPointer(str) {
+    return str.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+module.exports = getDef;
+//# sourceMappingURL=deepProperties.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepProperties.js","sourceRoot":"","sources":["../../src/definitions/deepProperties.ts"],"names":[],"mappings":";;AAEA,mCAAqC;AAErC,SAAwB,MAAM,CAAC,IAAwB;IACrD,OAAO;QACL,OAAO,EAAE,gBAAgB;QACzB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,QAAQ;QACpB,KAAK,EAAE,UAAU,MAAoC;YACnD,MAAM,KAAK,GAAG,EAAE,CAAA;YAChB,KAAK,MAAM,OAAO,IAAI,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;YAC7E,OAAO,EAAC,KAAK,EAAC,CAAA;QAChB,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,aAAa,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAC;YACvD,oBAAoB,EAAE,IAAA,qBAAa,EAAC,IAAI,CAAC;SAC1C;KACF,CAAA;AACH,CAAC;AAhBD,yBAgBC;AAED,SAAS,SAAS,CAAC,WAAmB,EAAE,MAAoB;IAC1D,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACvC,MAAM,UAAU,GAAiB,EAAE,CAAA;IACnC,IAAI,aAAa,GAAiB,UAAU,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACxC,IAAI,OAAO,GAAW,QAAQ,CAAC,CAAC,CAAC,CAAA;QACjC,MAAM,MAAM,GAAG,CAAC,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;QACxC,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAA;QACtC,MAAM,UAAU,GAA2B,CAAC,aAAa,CAAC,UAAU,GAAG,EAAE,CAAC,CAAA;QAC1E,IAAI,KAAiC,CAAA;QACrC,IAAI,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;YAC1B,IAAI,KAAK,GAAG,CAAC,OAAO,CAAA;YACpB,KAAK,GAAG,aAAa,CAAC,KAAK,GAAG,EAAE,CAAA;YAChC,aAAa,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;YACxC,OAAO,KAAK,EAAE;gBAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;SAC/B;aAAM;YACL,aAAa,CAAC,IAAI,GAAG,QAAQ,CAAA;SAC9B;QACD,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;QACpC,UAAU,CAAC,OAAO,CAAC,GAAG,aAAa,CAAA;QACnC,IAAI,KAAK;YAAE,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;KACrC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,SAAS,mBAAmB,CAAC,GAAW;IACtC,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;AACpD,CAAC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepRequired.d.ts

@@ -0,0 +1,2 @@
+import type { CodeKeywordDefinition } from "ajv";
+export default function getDef(): CodeKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepRequired.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+function getDef() {
+    return {
+        keyword: "deepRequired",
+        type: "object",
+        schemaType: "array",
+        code(ctx) {
+            const { schema, data } = ctx;
+            const props = schema.map((jp) => (0, codegen_1._) `(${getData(jp)}) === undefined`);
+            ctx.fail((0, codegen_1.or)(...props));
+            function getData(jsonPointer) {
+                if (jsonPointer === "")
+                    throw new Error("empty JSON pointer not allowed");
+                const segments = jsonPointer.split("/");
+                let x = data;
+                const xs = segments.map((s, i) => i ? (x = (0, codegen_1._) `${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`) : x);
+                return (0, codegen_1.and)(...xs);
+            }
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string", format: "json-pointer" },
+        },
+    };
+}
+exports.default = getDef;
+function unescapeJPSegment(s) {
+    return s.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+module.exports = getDef;
+//# sourceMappingURL=deepRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/deepRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepRequired.js","sourceRoot":"","sources":["../../src/definitions/deepRequired.ts"],"names":[],"mappings":";;AACA,sDAAsE;AAEtE,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,cAAc;QACvB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,IAAI,CAAC,GAAe;YAClB,MAAM,EAAC,MAAM,EAAE,IAAI,EAAC,GAAG,GAAG,CAAA;YAC1B,MAAM,KAAK,GAAI,MAAmB,CAAC,GAAG,CAAC,CAAC,EAAU,EAAE,EAAE,CAAC,IAAA,WAAC,EAAA,IAAI,OAAO,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAA;YACzF,GAAG,CAAC,IAAI,CAAC,IAAA,YAAE,EAAC,GAAG,KAAK,CAAC,CAAC,CAAA;YAEtB,SAAS,OAAO,CAAC,WAAmB;gBAClC,IAAI,WAAW,KAAK,EAAE;oBAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;gBACzE,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;gBACvC,IAAI,CAAC,GAAS,IAAI,CAAA;gBAClB,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAA,WAAC,EAAA,GAAG,CAAC,GAAG,IAAA,qBAAW,EAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAC1D,CAAA;gBACD,OAAO,IAAA,aAAG,EAAC,GAAG,EAAE,CAAC,CAAA;YACnB,CAAC;QACH,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAC;SAChD;KACF,CAAA;AACH,CAAC;AAzBD,yBAyBC;AAED,SAAS,iBAAiB,CAAC,CAAS;IAClC,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;AAClD,CAAC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.d.ts

@@ -0,0 +1,7 @@
+import type { FuncKeywordDefinition } from "ajv";
+export declare type DynamicDefaultFunc = (args?: Record<string, any>) => () => any;
+declare const DEFAULTS: Record<string, DynamicDefaultFunc | undefined>;
+declare const getDef: (() => FuncKeywordDefinition) & {
+    DEFAULTS: typeof DEFAULTS;
+};
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequences = {};
+const DEFAULTS = {
+    timestamp: () => () => Date.now(),
+    datetime: () => () => new Date().toISOString(),
+    date: () => () => new Date().toISOString().slice(0, 10),
+    time: () => () => new Date().toISOString().slice(11),
+    random: () => () => Math.random(),
+    randomint: (args) => {
+        var _a;
+        const max = (_a = args === null || args === void 0 ? void 0 : args.max) !== null && _a !== void 0 ? _a : 2;
+        return () => Math.floor(Math.random() * max);
+    },
+    seq: (args) => {
+        var _a;
+        const name = (_a = args === null || args === void 0 ? void 0 : args.name) !== null && _a !== void 0 ? _a : "";
+        sequences[name] || (sequences[name] = 0);
+        return () => sequences[name]++;
+    },
+};
+const getDef = Object.assign(_getDef, { DEFAULTS });
+function _getDef() {
+    return {
+        keyword: "dynamicDefaults",
+        type: "object",
+        schemaType: ["string", "object"],
+        modifying: true,
+        valid: true,
+        compile(schema, _parentSchema, it) {
+            if (!it.opts.useDefaults || it.compositeRule)
+                return () => true;
+            const fs = {};
+            for (const key in schema)
+                fs[key] = getDefault(schema[key]);
+            const empty = it.opts.useDefaults === "empty";
+            return (data) => {
+                for (const prop in schema) {
+                    if (data[prop] === undefined || (empty && (data[prop] === null || data[prop] === ""))) {
+                        data[prop] = fs[prop]();
+                    }
+                }
+                return true;
+            };
+        },
+        metaSchema: {
+            type: "object",
+            additionalProperties: {
+                anyOf: [
+                    { type: "string" },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["func", "args"],
+                        properties: {
+                            func: { type: "string" },
+                            args: { type: "object" },
+                        },
+                    },
+                ],
+            },
+        },
+    };
+}
+function getDefault(d) {
+    return typeof d == "object" ? getObjDefault(d) : getStrDefault(d);
+}
+function getObjDefault({ func, args }) {
+    const def = DEFAULTS[func];
+    assertDefined(func, def);
+    return def(args);
+}
+function getStrDefault(d = "") {
+    const def = DEFAULTS[d];
+    assertDefined(d, def);
+    return def();
+}
+function assertDefined(name, def) {
+    if (!def)
+        throw new Error(`invalid "dynamicDefaults" keyword property value: ${name}`);
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=dynamicDefaults.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicDefaults.js","sourceRoot":"","sources":["../../src/definitions/dynamicDefaults.ts"],"names":[],"mappings":";;AAEA,MAAM,SAAS,GAAuC,EAAE,CAAA;AAIxD,MAAM,QAAQ,GAAmD;IAC/D,SAAS,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IACjC,QAAQ,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;IAC9C,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;IACvD,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IACpD,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE;IACjC,SAAS,EAAE,CAAC,IAAqB,EAAE,EAAE;;QACnC,MAAM,GAAG,GAAG,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,GAAG,mCAAI,CAAC,CAAA;QAC1B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAA;IAC9C,CAAC;IACD,GAAG,EAAE,CAAC,IAAsB,EAAE,EAAE;;QAC9B,MAAM,IAAI,GAAG,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,IAAI,mCAAI,EAAE,CAAA;QAC7B,SAAS,CAAC,IAAI,MAAd,SAAS,CAAC,IAAI,IAAM,CAAC,EAAA;QACrB,OAAO,GAAG,EAAE,CAAE,SAAS,CAAC,IAAI,CAAY,EAAE,CAAA;IAC5C,CAAC;CACF,CAAA;AASD,MAAM,MAAM,GAER,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAC,QAAQ,EAAC,CAAC,CAAA;AAEtC,SAAS,OAAO;IACd,OAAO;QACL,OAAO,EAAE,iBAAiB;QAC1B,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;QAChC,SAAS,EAAE,IAAI;QACf,KAAK,EAAE,IAAI;QACX,OAAO,CAAC,MAAqB,EAAE,aAAa,EAAE,EAAa;YACzD,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,aAAa;gBAAE,OAAO,GAAG,EAAE,CAAC,IAAI,CAAA;YAC/D,MAAM,EAAE,GAA8B,EAAE,CAAA;YACxC,KAAK,MAAM,GAAG,IAAI,MAAM;gBAAE,EAAE,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;YAC3D,MAAM,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,KAAK,OAAO,CAAA;YAE7C,OAAO,CAAC,IAAyB,EAAE,EAAE;gBACnC,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE;oBACzB,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE;wBACrF,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAA;qBACxB;iBACF;gBACD,OAAO,IAAI,CAAA;YACb,CAAC,CAAA;QACH,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,oBAAoB,EAAE;gBACpB,KAAK,EAAE;oBACL,EAAC,IAAI,EAAE,QAAQ,EAAC;oBAChB;wBACE,IAAI,EAAE,QAAQ;wBACd,oBAAoB,EAAE,KAAK;wBAC3B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;wBAC1B,UAAU,EAAE;4BACV,IAAI,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;4BACtB,IAAI,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;yBACvB;qBACF;iBACF;aACF;SACF;KACF,CAAA;AACH,CAAC;AAED,SAAS,UAAU,CAAC,CAA6C;IAC/D,OAAO,OAAO,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;AACnE,CAAC;AAED,SAAS,aAAa,CAAC,EAAC,IAAI,EAAE,IAAI,EAAwB;IACxD,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC1B,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IACxB,OAAO,GAAG,CAAC,IAAI,CAAC,CAAA;AAClB,CAAC;AAED,SAAS,aAAa,CAAC,CAAC,GAAG,EAAE;IAC3B,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;IACvB,aAAa,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACrB,OAAO,GAAG,EAAE,CAAA;AACd,CAAC;AAED,SAAS,aAAa,CAAC,IAAY,EAAE,GAAwB;IAC3D,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,IAAI,EAAE,CAAC,CAAA;AACxF,CAAC;AAED,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/exclusiveRange.d.ts

@@ -0,0 +1,4 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare const getDef: GetDefinition<MacroKeywordDefinition>;
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _range_1 = __importDefault(require("./_range"));
+const getDef = (0, _range_1.default)("exclusiveRange");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=exclusiveRange.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exclusiveRange.js","sourceRoot":"","sources":["../../src/definitions/exclusiveRange.ts"],"names":[],"mappings":";;;;;AAEA,sDAAkC;AAElC,MAAM,MAAM,GAA0C,IAAA,gBAAW,EAAC,gBAAgB,CAAC,CAAA;AAEnF,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/index.d.ts

@@ -0,0 +1,6 @@
+import type { Vocabulary, ErrorNoParams } from "ajv";
+import type { DefinitionOptions } from "./_types";
+import { PatternRequiredError } from "./patternRequired";
+import { SelectError } from "./select";
+export default function ajvKeywords(opts?: DefinitionOptions): Vocabulary;
+export declare type AjvKeywordsError = PatternRequiredError | SelectError | ErrorNoParams<"range" | "exclusiveRange" | "anyRequired" | "oneRequired" | "allRequired" | "deepProperties" | "deepRequired" | "dynamicDefaults" | "instanceof" | "prohibited" | "regexp" | "transform" | "uniqueItemProperties">;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeof_1 = __importDefault(require("./typeof"));
+const instanceof_1 = __importDefault(require("./instanceof"));
+const range_1 = __importDefault(require("./range"));
+const exclusiveRange_1 = __importDefault(require("./exclusiveRange"));
+const regexp_1 = __importDefault(require("./regexp"));
+const transform_1 = __importDefault(require("./transform"));
+const uniqueItemProperties_1 = __importDefault(require("./uniqueItemProperties"));
+const allRequired_1 = __importDefault(require("./allRequired"));
+const anyRequired_1 = __importDefault(require("./anyRequired"));
+const oneRequired_1 = __importDefault(require("./oneRequired"));
+const patternRequired_1 = __importDefault(require("./patternRequired"));
+const prohibited_1 = __importDefault(require("./prohibited"));
+const deepProperties_1 = __importDefault(require("./deepProperties"));
+const deepRequired_1 = __importDefault(require("./deepRequired"));
+const dynamicDefaults_1 = __importDefault(require("./dynamicDefaults"));
+const select_1 = __importDefault(require("./select"));
+const definitions = [
+    typeof_1.default,
+    instanceof_1.default,
+    range_1.default,
+    exclusiveRange_1.default,
+    regexp_1.default,
+    transform_1.default,
+    uniqueItemProperties_1.default,
+    allRequired_1.default,
+    anyRequired_1.default,
+    oneRequired_1.default,
+    patternRequired_1.default,
+    prohibited_1.default,
+    deepProperties_1.default,
+    deepRequired_1.default,
+    dynamicDefaults_1.default,
+];
+function ajvKeywords(opts) {
+    return definitions.map((d) => d(opts)).concat((0, select_1.default)(opts));
+}
+exports.default = ajvKeywords;
+module.exports = ajvKeywords;
+//# sourceMappingURL=index.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/definitions/index.ts"],"names":[],"mappings":";;;;;AAEA,sDAAgC;AAChC,8DAAwC;AACxC,oDAA2B;AAC3B,sEAA6C;AAC7C,sDAA6B;AAC7B,4DAAmC;AACnC,kFAAyD;AACzD,gEAAuC;AACvC,gEAAuC;AACvC,gEAAuC;AACvC,wEAAuE;AACvE,8DAAqC;AACrC,sEAA6C;AAC7C,kEAAyC;AACzC,wEAA+C;AAC/C,sDAA+C;AAE/C,MAAM,WAAW,GAAuC;IACtD,gBAAS;IACT,oBAAa;IACb,eAAK;IACL,wBAAc;IACd,gBAAM;IACN,mBAAS;IACT,8BAAoB;IACpB,qBAAW;IACX,qBAAW;IACX,qBAAW;IACX,yBAAe;IACf,oBAAU;IACV,wBAAc;IACd,sBAAY;IACZ,yBAAe;CAChB,CAAA;AAED,SAAwB,WAAW,CAAC,IAAwB;IAC1D,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAA,gBAAS,EAAC,IAAI,CAAC,CAAC,CAAA;AAChE,CAAC;AAFD,8BAEC;AAqBD,MAAM,CAAC,OAAO,GAAG,WAAW,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/instanceof.d.ts

@@ -0,0 +1,7 @@
+import type { FuncKeywordDefinition } from "ajv";
+declare type Constructor = new (...args: any[]) => any;
+declare const CONSTRUCTORS: Record<string, Constructor | undefined>;
+declare const getDef: (() => FuncKeywordDefinition) & {
+    CONSTRUCTORS: typeof CONSTRUCTORS;
+};
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/instanceof.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CONSTRUCTORS = {
+    Object,
+    Array,
+    Function,
+    Number,
+    String,
+    Date,
+    RegExp,
+};
+/* istanbul ignore else */
+if (typeof Buffer != "undefined")
+    CONSTRUCTORS.Buffer = Buffer;
+/* istanbul ignore else */
+if (typeof Promise != "undefined")
+    CONSTRUCTORS.Promise = Promise;
+const getDef = Object.assign(_getDef, { CONSTRUCTORS });
+function _getDef() {
+    return {
+        keyword: "instanceof",
+        schemaType: ["string", "array"],
+        compile(schema) {
+            if (typeof schema == "string") {
+                const C = getConstructor(schema);
+                return (data) => data instanceof C;
+            }
+            if (Array.isArray(schema)) {
+                const constructors = schema.map(getConstructor);
+                return (data) => {
+                    for (const C of constructors) {
+                        if (data instanceof C)
+                            return true;
+                    }
+                    return false;
+                };
+            }
+            /* istanbul ignore next */
+            throw new Error("ajv implementation error");
+        },
+        metaSchema: {
+            anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        },
+    };
+}
+function getConstructor(c) {
+    const C = CONSTRUCTORS[c];
+    if (C)
+        return C;
+    throw new Error(`invalid "instanceof" keyword value ${c}`);
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=instanceof.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/instanceof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceof.js","sourceRoot":"","sources":["../../src/definitions/instanceof.ts"],"names":[],"mappings":";;AAIA,MAAM,YAAY,GAA4C;IAC5D,MAAM;IACN,KAAK;IACL,QAAQ;IACR,MAAM;IACN,MAAM;IACN,IAAI;IACJ,MAAM;CACP,CAAA;AAED,0BAA0B;AAC1B,IAAI,OAAO,MAAM,IAAI,WAAW;IAAE,YAAY,CAAC,MAAM,GAAG,MAAM,CAAA;AAE9D,0BAA0B;AAC1B,IAAI,OAAO,OAAO,IAAI,WAAW;IAAE,YAAY,CAAC,OAAO,GAAG,OAAO,CAAA;AAEjE,MAAM,MAAM,GAER,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAC,YAAY,EAAC,CAAC,CAAA;AAE1C,SAAS,OAAO;IACd,OAAO;QACL,OAAO,EAAE,YAAY;QACrB,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC/B,OAAO,CAAC,MAAyB;YAC/B,IAAI,OAAO,MAAM,IAAI,QAAQ,EAAE;gBAC7B,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAA;gBAChC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,YAAY,CAAC,CAAA;aACnC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACzB,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;gBAC/C,OAAO,CAAC,IAAI,EAAE,EAAE;oBACd,KAAK,MAAM,CAAC,IAAI,YAAY,EAAE;wBAC5B,IAAI,IAAI,YAAY,CAAC;4BAAE,OAAO,IAAI,CAAA;qBACnC;oBACD,OAAO,KAAK,CAAA;gBACd,CAAC,CAAA;aACF;YAED,0BAA0B;YAC1B,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA;QAC7C,CAAC;QACD,UAAU,EAAE;YACV,KAAK,EAAE,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAC,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC,EAAC,CAAC;SACpE;KACF,CAAA;AACH,CAAC;AAED,SAAS,cAAc,CAAC,CAAS;IAC/B,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;IACzB,IAAI,CAAC;QAAE,OAAO,CAAC,CAAA;IACf,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,EAAE,CAAC,CAAA;AAC5D,CAAC;AAED,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/oneRequired.d.ts

@@ -0,0 +1,4 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare const getDef: GetDefinition<MacroKeywordDefinition>;
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/oneRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _required_1 = __importDefault(require("./_required"));
+const getDef = (0, _required_1.default)("oneRequired");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=oneRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/oneRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oneRequired.js","sourceRoot":"","sources":["../../src/definitions/oneRequired.ts"],"names":[],"mappings":";;;;;AAEA,4DAAwC;AAExC,MAAM,MAAM,GAA0C,IAAA,mBAAc,EAAC,aAAa,CAAC,CAAA;AAEnF,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/patternRequired.d.ts

@@ -0,0 +1,5 @@
+import type { CodeKeywordDefinition, ErrorObject } from "ajv";
+export declare type PatternRequiredError = ErrorObject<"patternRequired", {
+    missingPattern: string;
+}>;
+export default function getDef(): CodeKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/patternRequired.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const _util_1 = require("./_util");
+const error = {
+    message: ({ params: { missingPattern } }) => (0, codegen_1.str) `should have property matching pattern '${missingPattern}'`,
+    params: ({ params: { missingPattern } }) => (0, codegen_1._) `{missingPattern: ${missingPattern}}`,
+};
+function getDef() {
+    return {
+        keyword: "patternRequired",
+        type: "object",
+        schemaType: "array",
+        error,
+        code(cxt) {
+            const { gen, schema, data } = cxt;
+            if (schema.length === 0)
+                return;
+            const valid = gen.let("valid", true);
+            for (const pat of schema)
+                validateProperties(pat);
+            function validateProperties(pattern) {
+                const matched = gen.let("matched", false);
+                gen.forIn("key", data, (key) => {
+                    gen.assign(matched, (0, codegen_1._) `${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`);
+                    gen.if(matched, () => gen.break());
+                });
+                cxt.setParams({ missingPattern: pattern });
+                gen.assign(valid, (0, codegen_1.and)(valid, matched));
+                cxt.pass(valid);
+            }
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string", format: "regex" },
+            uniqueItems: true,
+        },
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=patternRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/patternRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patternRequired.js","sourceRoot":"","sources":["../../src/definitions/patternRequired.ts"],"names":[],"mappings":";;AACA,sDAAoD;AACpD,mCAAkC;AAIlC,MAAM,KAAK,GAA2B;IACpC,OAAO,EAAE,CAAC,EAAC,MAAM,EAAE,EAAC,cAAc,EAAC,EAAC,EAAE,EAAE,CACtC,IAAA,aAAG,EAAA,0CAA0C,cAAc,GAAG;IAChE,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,EAAC,cAAc,EAAC,EAAC,EAAE,EAAE,CAAC,IAAA,WAAC,EAAA,oBAAoB,cAAc,GAAG;CAC/E,CAAA;AAED,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,iBAAiB;QAC1B,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK;QACL,IAAI,CAAC,GAAe;YAClB,MAAM,EAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAC,GAAG,GAAG,CAAA;YAC/B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAM;YAC/B,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;YACpC,KAAK,MAAM,GAAG,IAAI,MAAM;gBAAE,kBAAkB,CAAC,GAAG,CAAC,CAAA;YAEjD,SAAS,kBAAkB,CAAC,OAAe;gBACzC,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;gBAEzC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;oBAC7B,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,IAAA,WAAC,EAAA,GAAG,IAAA,kBAAU,EAAC,GAAG,EAAE,OAAO,CAAC,SAAS,GAAG,GAAG,CAAC,CAAA;oBAChE,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAA;gBACpC,CAAC,CAAC,CAAA;gBAEF,GAAG,CAAC,SAAS,CAAC,EAAC,cAAc,EAAE,OAAO,EAAC,CAAC,CAAA;gBACxC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,IAAA,aAAG,EAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAA;gBACtC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACjB,CAAC;QACH,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAC;YACxC,WAAW,EAAE,IAAI;SAClB;KACF,CAAA;AACH,CAAC;AA/BD,yBA+BC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/prohibited.d.ts

@@ -0,0 +1,2 @@
+import type { MacroKeywordDefinition } from "ajv";
+export default function getDef(): MacroKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/prohibited.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDef() {
+    return {
+        keyword: "prohibited",
+        type: "object",
+        schemaType: "array",
+        macro: function (schema) {
+            if (schema.length === 0)
+                return true;
+            if (schema.length === 1)
+                return { not: { required: schema } };
+            return { not: { anyOf: schema.map((p) => ({ required: [p] })) } };
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string" },
+        },
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=prohibited.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/prohibited.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prohibited.js","sourceRoot":"","sources":["../../src/definitions/prohibited.ts"],"names":[],"mappings":";;AAEA,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,YAAY;QACrB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK,EAAE,UAAU,MAAgB;YAC/B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAA;YACpC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAC,GAAG,EAAE,EAAC,QAAQ,EAAE,MAAM,EAAC,EAAC,CAAA;YACzD,OAAO,EAAC,GAAG,EAAE,EAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAC,EAAC,CAAA;QAC7D,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAA;AACH,CAAC;AAfD,yBAeC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/range.d.ts

@@ -0,0 +1,4 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare const getDef: GetDefinition<MacroKeywordDefinition>;
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/range.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _range_1 = __importDefault(require("./_range"));
+const getDef = (0, _range_1.default)("range");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=range.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","sourceRoot":"","sources":["../../src/definitions/range.ts"],"names":[],"mappings":";;;;;AAEA,sDAAkC;AAElC,MAAM,MAAM,GAA0C,IAAA,gBAAW,EAAC,OAAO,CAAC,CAAA;AAE1E,kBAAe,MAAM,CAAA;AACrB,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/regexp.d.ts

@@ -0,0 +1,2 @@
+import type { CodeKeywordDefinition } from "ajv";
+export default function getDef(): CodeKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/regexp.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const _util_1 = require("./_util");
+const regexpMetaSchema = {
+    type: "object",
+    properties: {
+        pattern: { type: "string" },
+        flags: { type: "string", nullable: true },
+    },
+    required: ["pattern"],
+    additionalProperties: false,
+};
+const metaRegexp = /^\/(.*)\/([gimuy]*)$/;
+function getDef() {
+    return {
+        keyword: "regexp",
+        type: "string",
+        schemaType: ["string", "object"],
+        code(cxt) {
+            const { data, schema } = cxt;
+            const regx = getRegExp(schema);
+            cxt.pass((0, codegen_1._) `${regx}.test(${data})`);
+            function getRegExp(sch) {
+                if (typeof sch == "object")
+                    return (0, _util_1.usePattern)(cxt, sch.pattern, sch.flags);
+                const rx = metaRegexp.exec(sch);
+                if (rx)
+                    return (0, _util_1.usePattern)(cxt, rx[1], rx[2]);
+                throw new Error("cannot parse string into RegExp");
+            }
+        },
+        metaSchema: {
+            anyOf: [{ type: "string" }, regexpMetaSchema],
+        },
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=regexp.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/regexp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexp.js","sourceRoot":"","sources":["../../src/definitions/regexp.ts"],"names":[],"mappings":";;AACA,sDAA0C;AAC1C,mCAAkC;AAOlC,MAAM,gBAAgB,GAAiC;IACrD,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,OAAO,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;QACzB,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAC;KACxC;IACD,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,oBAAoB,EAAE,KAAK;CAC5B,CAAA;AAED,MAAM,UAAU,GAAG,sBAAsB,CAAA;AAEzC,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,QAAQ;QACjB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;QAChC,IAAI,CAAC,GAAe;YAClB,MAAM,EAAC,IAAI,EAAE,MAAM,EAAC,GAAG,GAAG,CAAA;YAC1B,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,CAAA;YAC9B,GAAG,CAAC,IAAI,CAAC,IAAA,WAAC,EAAA,GAAG,IAAI,SAAS,IAAI,GAAG,CAAC,CAAA;YAElC,SAAS,SAAS,CAAC,GAA0B;gBAC3C,IAAI,OAAO,GAAG,IAAI,QAAQ;oBAAE,OAAO,IAAA,kBAAU,EAAC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAA;gBAC1E,MAAM,EAAE,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBAC/B,IAAI,EAAE;oBAAE,OAAO,IAAA,kBAAU,EAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;gBAC5C,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;YACpD,CAAC;QACH,CAAC;QACD,UAAU,EAAE;YACV,KAAK,EAAE,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAC,EAAE,gBAAgB,CAAC;SAC5C;KACF,CAAA;AACH,CAAC;AArBD,yBAqBC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/select.d.ts

@@ -0,0 +1,7 @@
+import type { KeywordDefinition, ErrorObject } from "ajv";
+import type { DefinitionOptions } from "./_types";
+export declare type SelectError = ErrorObject<"select", {
+    failingCase?: string;
+    failingDefault?: true;
+}>;
+export default function getDef(opts?: DefinitionOptions): KeywordDefinition[];

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/select.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const _util_1 = require("./_util");
+const error = {
+    message: ({ params: { schemaProp } }) => schemaProp
+        ? (0, codegen_1.str) `should match case "${schemaProp}" schema`
+        : (0, codegen_1.str) `should match default case schema`,
+    params: ({ params: { schemaProp } }) => schemaProp ? (0, codegen_1._) `{failingCase: ${schemaProp}}` : (0, codegen_1._) `{failingDefault: true}`,
+};
+function getDef(opts) {
+    const metaSchema = (0, _util_1.metaSchemaRef)(opts);
+    return [
+        {
+            keyword: "select",
+            schemaType: ["string", "number", "boolean", "null"],
+            $data: true,
+            error,
+            dependencies: ["selectCases"],
+            code(cxt) {
+                const { gen, schemaCode, parentSchema } = cxt;
+                cxt.block$data(codegen_1.nil, () => {
+                    const valid = gen.let("valid", true);
+                    const schValid = gen.name("_valid");
+                    const value = gen.const("value", (0, codegen_1._) `${schemaCode} === null ? "null" : ${schemaCode}`);
+                    gen.if(false); // optimizer should remove it from generated code
+                    for (const schemaProp in parentSchema.selectCases) {
+                        cxt.setParams({ schemaProp });
+                        gen.elseIf((0, codegen_1._) `"" + ${value} == ${schemaProp}`); // intentional ==, to match numbers and booleans
+                        const schCxt = cxt.subschema({ keyword: "selectCases", schemaProp }, schValid);
+                        cxt.mergeEvaluated(schCxt, codegen_1.Name);
+                        gen.assign(valid, schValid);
+                    }
+                    gen.else();
+                    if (parentSchema.selectDefault !== undefined) {
+                        cxt.setParams({ schemaProp: undefined });
+                        const schCxt = cxt.subschema({ keyword: "selectDefault" }, schValid);
+                        cxt.mergeEvaluated(schCxt, codegen_1.Name);
+                        gen.assign(valid, schValid);
+                    }
+                    gen.endIf();
+                    cxt.pass(valid);
+                });
+            },
+        },
+        {
+            keyword: "selectCases",
+            dependencies: ["select"],
+            metaSchema: {
+                type: "object",
+                additionalProperties: metaSchema,
+            },
+        },
+        {
+            keyword: "selectDefault",
+            dependencies: ["select", "selectCases"],
+            metaSchema,
+        },
+    ];
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=select.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/definitions/select.ts"],"names":[],"mappings":"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"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/transform.d.ts

@@ -0,0 +1,13 @@
+import type { CodeKeywordDefinition } from "ajv";
+declare type TransformName = "trimStart" | "trimEnd" | "trimLeft" | "trimRight" | "trim" | "toLowerCase" | "toUpperCase" | "toEnumCase";
+interface TransformConfig {
+    hash: Record<string, string | undefined>;
+}
+declare type Transform = (s: string, cfg?: TransformConfig) => string;
+declare const transform: {
+    [key in TransformName]: Transform;
+};
+declare const getDef: (() => CodeKeywordDefinition) & {
+    transform: typeof transform;
+};
+export default getDef;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/transform.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const transform = {
+    trimStart: (s) => s.trimStart(),
+    trimEnd: (s) => s.trimEnd(),
+    trimLeft: (s) => s.trimStart(),
+    trimRight: (s) => s.trimEnd(),
+    trim: (s) => s.trim(),
+    toLowerCase: (s) => s.toLowerCase(),
+    toUpperCase: (s) => s.toUpperCase(),
+    toEnumCase: (s, cfg) => (cfg === null || cfg === void 0 ? void 0 : cfg.hash[configKey(s)]) || s,
+};
+const getDef = Object.assign(_getDef, { transform });
+function _getDef() {
+    return {
+        keyword: "transform",
+        schemaType: "array",
+        before: "enum",
+        code(cxt) {
+            const { gen, data, schema, parentSchema, it } = cxt;
+            const { parentData, parentDataProperty } = it;
+            const tNames = schema;
+            if (!tNames.length)
+                return;
+            let cfg;
+            if (tNames.includes("toEnumCase")) {
+                const config = getEnumCaseCfg(parentSchema);
+                cfg = gen.scopeValue("obj", { ref: config, code: (0, codegen_1.stringify)(config) });
+            }
+            gen.if((0, codegen_1._) `typeof ${data} == "string" && ${parentData} !== undefined`, () => {
+                gen.assign(data, transformExpr(tNames.slice()));
+                gen.assign((0, codegen_1._) `${parentData}[${parentDataProperty}]`, data);
+            });
+            function transformExpr(ts) {
+                if (!ts.length)
+                    return data;
+                const t = ts.pop();
+                if (!(t in transform))
+                    throw new Error(`transform: unknown transformation ${t}`);
+                const func = gen.scopeValue("func", {
+                    ref: transform[t],
+                    code: (0, codegen_1._) `require("ajv-keywords/dist/definitions/transform").transform${(0, codegen_1.getProperty)(t)}`,
+                });
+                const arg = transformExpr(ts);
+                return cfg && t === "toEnumCase" ? (0, codegen_1._) `${func}(${arg}, ${cfg})` : (0, codegen_1._) `${func}(${arg})`;
+            }
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string", enum: Object.keys(transform) },
+        },
+    };
+}
+function getEnumCaseCfg(parentSchema) {
+    // build hash table to enum values
+    const cfg = { hash: {} };
+    // requires `enum` in the same schema as transform
+    if (!parentSchema.enum)
+        throw new Error('transform: "toEnumCase" requires "enum"');
+    for (const v of parentSchema.enum) {
+        if (typeof v !== "string")
+            continue;
+        const k = configKey(v);
+        // requires all `enum` values have unique keys
+        if (cfg.hash[k]) {
+            throw new Error('transform: "toEnumCase" requires all lowercased "enum" values to be unique');
+        }
+        cfg.hash[k] = v;
+    }
+    return cfg;
+}
+function configKey(s) {
+    return s.toLowerCase();
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=transform.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../src/definitions/transform.ts"],"names":[],"mappings":"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"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/typeof.d.ts

@@ -0,0 +1,2 @@
+import type { CodeKeywordDefinition } from "ajv";
+export default function getDef(): CodeKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/typeof.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const TYPES = ["undefined", "string", "number", "object", "function", "boolean", "symbol"];
+function getDef() {
+    return {
+        keyword: "typeof",
+        schemaType: ["string", "array"],
+        code(cxt) {
+            const { data, schema, schemaValue } = cxt;
+            cxt.fail(typeof schema == "string"
+                ? (0, codegen_1._) `typeof ${data} != ${schema}`
+                : (0, codegen_1._) `${schemaValue}.indexOf(typeof ${data}) < 0`);
+        },
+        metaSchema: {
+            anyOf: [
+                { type: "string", enum: TYPES },
+                { type: "array", items: { type: "string", enum: TYPES } },
+            ],
+        },
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=typeof.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/typeof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeof.js","sourceRoot":"","sources":["../../src/definitions/typeof.ts"],"names":[],"mappings":";;AACA,sDAA0C;AAE1C,MAAM,KAAK,GAAG,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;AAE1F,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,QAAQ;QACjB,UAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC/B,IAAI,CAAC,GAAe;YAClB,MAAM,EAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAC,GAAG,GAAG,CAAA;YACvC,GAAG,CAAC,IAAI,CACN,OAAO,MAAM,IAAI,QAAQ;gBACvB,CAAC,CAAC,IAAA,WAAC,EAAA,UAAU,IAAI,OAAO,MAAM,EAAE;gBAChC,CAAC,CAAC,IAAA,WAAC,EAAA,GAAG,WAAW,mBAAmB,IAAI,OAAO,CAClD,CAAA;QACH,CAAC;QACD,UAAU,EAAE;YACV,KAAK,EAAE;gBACL,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAC;gBAC7B,EAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAC,EAAC;aACtD;SACF;KACF,CAAA;AACH,CAAC;AAnBD,yBAmBC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.d.ts

@@ -0,0 +1,2 @@
+import type { FuncKeywordDefinition } from "ajv";
+export default function getDef(): FuncKeywordDefinition;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const equal = require("fast-deep-equal");
+const SCALAR_TYPES = ["number", "integer", "string", "boolean", "null"];
+function getDef() {
+    return {
+        keyword: "uniqueItemProperties",
+        type: "array",
+        schemaType: "array",
+        compile(keys, parentSchema) {
+            const scalar = getScalarKeys(keys, parentSchema);
+            return (data) => {
+                if (data.length <= 1)
+                    return true;
+                for (let k = 0; k < keys.length; k++) {
+                    const key = keys[k];
+                    if (scalar[k]) {
+                        const hash = {};
+                        for (const x of data) {
+                            if (!x || typeof x != "object")
+                                continue;
+                            let p = x[key];
+                            if (p && typeof p == "object")
+                                continue;
+                            if (typeof p == "string")
+                                p = '"' + p;
+                            if (hash[p])
+                                return false;
+                            hash[p] = true;
+                        }
+                    }
+                    else {
+                        for (let i = data.length; i--;) {
+                            const x = data[i];
+                            if (!x || typeof x != "object")
+                                continue;
+                            for (let j = i; j--;) {
+                                const y = data[j];
+                                if (y && typeof y == "object" && equal(x[key], y[key]))
+                                    return false;
+                            }
+                        }
+                    }
+                }
+                return true;
+            };
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string" },
+        },
+    };
+}
+exports.default = getDef;
+function getScalarKeys(keys, schema) {
+    return keys.map((key) => {
+        var _a, _b, _c;
+        const t = (_c = (_b = (_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.type;
+        return Array.isArray(t)
+            ? !t.includes("object") && !t.includes("array")
+            : SCALAR_TYPES.includes(t);
+    });
+}
+module.exports = getDef;
+//# sourceMappingURL=uniqueItemProperties.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueItemProperties.js","sourceRoot":"","sources":["../../src/definitions/uniqueItemProperties.ts"],"names":[],"mappings":";;AACA,yCAAyC;AAEzC,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CAAA;AAEvE,SAAwB,MAAM;IAC5B,OAAO;QACL,OAAO,EAAE,sBAAsB;QAC/B,IAAI,EAAE,OAAO;QACb,UAAU,EAAE,OAAO;QACnB,OAAO,CAAC,IAAc,EAAE,YAA6B;YACnD,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;YAEhD,OAAO,CAAC,IAAI,EAAE,EAAE;gBACd,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC;oBAAE,OAAO,IAAI,CAAA;gBACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACpC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;oBACnB,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE;wBACb,MAAM,IAAI,GAAwB,EAAE,CAAA;wBACpC,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE;4BACpB,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,QAAQ;gCAAE,SAAQ;4BACxC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;4BACd,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,QAAQ;gCAAE,SAAQ;4BACvC,IAAI,OAAO,CAAC,IAAI,QAAQ;gCAAE,CAAC,GAAG,GAAG,GAAG,CAAC,CAAA;4BACrC,IAAI,IAAI,CAAC,CAAC,CAAC;gCAAE,OAAO,KAAK,CAAA;4BACzB,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;yBACf;qBACF;yBAAM;wBACL,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,GAAI;4BAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;4BACjB,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,QAAQ;gCAAE,SAAQ;4BACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAI;gCACrB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;gCACjB,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;oCAAE,OAAO,KAAK,CAAA;6BACrE;yBACF;qBACF;iBACF;gBACD,OAAO,IAAI,CAAA;YACb,CAAC,CAAA;QACH,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAA;AACH,CAAC;AAzCD,yBAyCC;AAED,SAAS,aAAa,CAAC,IAAc,EAAE,MAAuB;IAC5D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;;QACtB,MAAM,CAAC,GAAG,MAAA,MAAA,MAAA,MAAM,CAAC,KAAK,0CAAE,UAAU,0CAAG,GAAG,CAAC,0CAAE,IAAI,CAAA;QAC/C,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;YAC/C,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IAC9B,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,CAAC,OAAO,GAAG,MAAM,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "ajv";
+export { AjvKeywordsError } from "./definitions";
+declare const ajvKeywords: Plugin<string | string[]>;
+export default ajvKeywords;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const keywords_1 = __importDefault(require("./keywords"));
+const ajvKeywords = (ajv, keyword) => {
+    if (Array.isArray(keyword)) {
+        for (const k of keyword)
+            get(k)(ajv);
+        return ajv;
+    }
+    if (keyword) {
+        get(keyword)(ajv);
+        return ajv;
+    }
+    for (keyword in keywords_1.default)
+        get(keyword)(ajv);
+    return ajv;
+};
+ajvKeywords.get = get;
+function get(keyword) {
+    const defFunc = keywords_1.default[keyword];
+    if (!defFunc)
+        throw new Error("Unknown keyword " + keyword);
+    return defFunc;
+}
+exports.default = ajvKeywords;
+module.exports = ajvKeywords;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+module.exports.default = ajvKeywords;
+//# sourceMappingURL=index.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAEA,0DAAgC;AAIhC,MAAM,WAAW,GAA8B,CAAC,GAAQ,EAAE,OAA2B,EAAO,EAAE;IAC5F,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;QAC1B,KAAK,MAAM,CAAC,IAAI,OAAO;YAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;QACpC,OAAO,GAAG,CAAA;KACX;IACD,IAAI,OAAO,EAAE;QACX,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAA;QACjB,OAAO,GAAG,CAAA;KACX;IACD,KAAK,OAAO,IAAI,kBAAO;QAAE,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAA;IAC1C,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA;AAED,WAAW,CAAC,GAAG,GAAG,GAAG,CAAA;AAErB,SAAS,GAAG,CAAC,OAAe;IAC1B,MAAM,OAAO,GAAG,kBAAO,CAAC,OAAO,CAAC,CAAA;IAChC,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,GAAG,OAAO,CAAC,CAAA;IAC3D,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,kBAAe,WAAW,CAAA;AAC1B,MAAM,CAAC,OAAO,GAAG,WAAW,CAAA;AAE5B,sEAAsE;AACtE,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,WAAW,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/allRequired.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const allRequired: Plugin<undefined>;
+export default allRequired;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/allRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const allRequired_1 = __importDefault(require("../definitions/allRequired"));
+const allRequired = (ajv) => ajv.addKeyword((0, allRequired_1.default)());
+exports.default = allRequired;
+module.exports = allRequired;
+//# sourceMappingURL=allRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/allRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allRequired.js","sourceRoot":"","sources":["../../src/keywords/allRequired.ts"],"names":[],"mappings":";;;;;AACA,6EAA+C;AAE/C,MAAM,WAAW,GAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAA,qBAAM,GAAE,CAAC,CAAA;AAExE,kBAAe,WAAW,CAAA;AAC1B,MAAM,CAAC,OAAO,GAAG,WAAW,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/anyRequired.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const anyRequired: Plugin<undefined>;
+export default anyRequired;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/anyRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anyRequired_1 = __importDefault(require("../definitions/anyRequired"));
+const anyRequired = (ajv) => ajv.addKeyword((0, anyRequired_1.default)());
+exports.default = anyRequired;
+module.exports = anyRequired;
+//# sourceMappingURL=anyRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/anyRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyRequired.js","sourceRoot":"","sources":["../../src/keywords/anyRequired.ts"],"names":[],"mappings":";;;;;AACA,6EAA+C;AAE/C,MAAM,WAAW,GAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAA,qBAAM,GAAE,CAAC,CAAA;AAExE,kBAAe,WAAW,CAAA;AAC1B,MAAM,CAAC,OAAO,GAAG,WAAW,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepProperties.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "ajv";
+import type { DefinitionOptions } from "../definitions/_types";
+declare const deepProperties: Plugin<DefinitionOptions>;
+export default deepProperties;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepProperties.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepProperties_1 = __importDefault(require("../definitions/deepProperties"));
+const deepProperties = (ajv, opts) => ajv.addKeyword((0, deepProperties_1.default)(opts));
+exports.default = deepProperties;
+module.exports = deepProperties;
+//# sourceMappingURL=deepProperties.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepProperties.js","sourceRoot":"","sources":["../../src/keywords/deepProperties.ts"],"names":[],"mappings":";;;;;AACA,mFAAkD;AAGlD,MAAM,cAAc,GAA8B,CAAC,GAAG,EAAE,IAAwB,EAAE,EAAE,CAClF,GAAG,CAAC,UAAU,CAAC,IAAA,wBAAM,EAAC,IAAI,CAAC,CAAC,CAAA;AAE9B,kBAAe,cAAc,CAAA;AAC7B,MAAM,CAAC,OAAO,GAAG,cAAc,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepRequired.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const deepRequired: Plugin<undefined>;
+export default deepRequired;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepRequired_1 = __importDefault(require("../definitions/deepRequired"));
+const deepRequired = (ajv) => ajv.addKeyword((0, deepRequired_1.default)());
+exports.default = deepRequired;
+module.exports = deepRequired;
+//# sourceMappingURL=deepRequired.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/deepRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepRequired.js","sourceRoot":"","sources":["../../src/keywords/deepRequired.ts"],"names":[],"mappings":";;;;;AACA,+EAAgD;AAEhD,MAAM,YAAY,GAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAA,sBAAM,GAAE,CAAC,CAAA;AAEzE,kBAAe,YAAY,CAAA;AAC3B,MAAM,CAAC,OAAO,GAAG,YAAY,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const dynamicDefaults: Plugin<undefined>;
+export default dynamicDefaults;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynamicDefaults_1 = __importDefault(require("../definitions/dynamicDefaults"));
+const dynamicDefaults = (ajv) => ajv.addKeyword((0, dynamicDefaults_1.default)());
+exports.default = dynamicDefaults;
+module.exports = dynamicDefaults;
+//# sourceMappingURL=dynamicDefaults.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicDefaults.js","sourceRoot":"","sources":["../../src/keywords/dynamicDefaults.ts"],"names":[],"mappings":";;;;;AACA,qFAAmD;AAEnD,MAAM,eAAe,GAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAA,yBAAM,GAAE,CAAC,CAAA;AAE5E,kBAAe,eAAe,CAAA;AAC9B,MAAM,CAAC,OAAO,GAAG,eAAe,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/exclusiveRange.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const exclusiveRange: Plugin<undefined>;
+export default exclusiveRange;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exclusiveRange_1 = __importDefault(require("../definitions/exclusiveRange"));
+const exclusiveRange = (ajv) => ajv.addKeyword((0, exclusiveRange_1.default)());
+exports.default = exclusiveRange;
+module.exports = exclusiveRange;
+//# sourceMappingURL=exclusiveRange.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exclusiveRange.js","sourceRoot":"","sources":["../../src/keywords/exclusiveRange.ts"],"names":[],"mappings":";;;;;AACA,mFAAkD;AAElD,MAAM,cAAc,GAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAA,wBAAM,GAAE,CAAC,CAAA;AAE3E,kBAAe,cAAc,CAAA;AAC7B,MAAM,CAAC,OAAO,GAAG,cAAc,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const ajvKeywords: Record<string, Plugin<any> | undefined>;
+export default ajvKeywords;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeof_1 = __importDefault(require("./typeof"));
+const instanceof_1 = __importDefault(require("./instanceof"));
+const range_1 = __importDefault(require("./range"));
+const exclusiveRange_1 = __importDefault(require("./exclusiveRange"));
+const regexp_1 = __importDefault(require("./regexp"));
+const transform_1 = __importDefault(require("./transform"));
+const uniqueItemProperties_1 = __importDefault(require("./uniqueItemProperties"));
+const allRequired_1 = __importDefault(require("./allRequired"));
+const anyRequired_1 = __importDefault(require("./anyRequired"));
+const oneRequired_1 = __importDefault(require("./oneRequired"));
+const patternRequired_1 = __importDefault(require("./patternRequired"));
+const prohibited_1 = __importDefault(require("./prohibited"));
+const deepProperties_1 = __importDefault(require("./deepProperties"));
+const deepRequired_1 = __importDefault(require("./deepRequired"));
+const dynamicDefaults_1 = __importDefault(require("./dynamicDefaults"));
+const select_1 = __importDefault(require("./select"));
+// TODO type
+const ajvKeywords = {
+    typeof: typeof_1.default,
+    instanceof: instanceof_1.default,
+    range: range_1.default,
+    exclusiveRange: exclusiveRange_1.default,
+    regexp: regexp_1.default,
+    transform: transform_1.default,
+    uniqueItemProperties: uniqueItemProperties_1.default,
+    allRequired: allRequired_1.default,
+    anyRequired: anyRequired_1.default,
+    oneRequired: oneRequired_1.default,
+    patternRequired: patternRequired_1.default,
+    prohibited: prohibited_1.default,
+    deepProperties: deepProperties_1.default,
+    deepRequired: deepRequired_1.default,
+    dynamicDefaults: dynamicDefaults_1.default,
+    select: select_1.default,
+};
+exports.default = ajvKeywords;
+module.exports = ajvKeywords;
+//# sourceMappingURL=index.js.map

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keywords/index.ts"],"names":[],"mappings":";;;;;AACA,sDAAmC;AACnC,8DAA2C;AAC3C,oDAA2B;AAC3B,sEAA6C;AAC7C,sDAA6B;AAC7B,4DAAmC;AACnC,kFAAyD;AACzD,gEAAuC;AACvC,gEAAuC;AACvC,gEAAuC;AACvC,wEAA+C;AAC/C,8DAAqC;AACrC,sEAA6C;AAC7C,kEAAyC;AACzC,wEAA+C;AAC/C,sDAA6B;AAE7B,YAAY;AACZ,MAAM,WAAW,GAA4C;IAC3D,MAAM,EAAE,gBAAY;IACpB,UAAU,EAAE,oBAAgB;IAC5B,KAAK,EAAL,eAAK;IACL,cAAc,EAAd,wBAAc;IACd,MAAM,EAAN,gBAAM;IACN,SAAS,EAAT,mBAAS;IACT,oBAAoB,EAApB,8BAAoB;IACpB,WAAW,EAAX,qBAAW;IACX,WAAW,EAAX,qBAAW;IACX,WAAW,EAAX,qBAAW;IACX,eAAe,EAAf,yBAAe;IACf,UAAU,EAAV,oBAAU;IACV,cAAc,EAAd,wBAAc;IACd,YAAY,EAAZ,sBAAY;IACZ,eAAe,EAAf,yBAAe;IACf,MAAM,EAAN,gBAAM;CACP,CAAA;AAED,kBAAe,WAAW,CAAA;AAC1B,MAAM,CAAC,OAAO,GAAG,WAAW,CAAA"}

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/instanceof.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "ajv";
+declare const instanceofPlugin: Plugin<undefined>;
+export default instanceofPlugin;

node_modules/mini-css-extract-plugin/node_modules/ajv-keywords/dist/keywords/instanceof.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const instanceof_1 = __importDefault(require("../definitions/instanceof"));
+const instanceofPlugin = (ajv) => ajv.addKeyword((0, instanceof_1.default)());
+exports.default = instanceofPlugin;
+module.exports = instanceofPlugin;
+//# sourceMappingURL=instanceof.js.map