Index: imaps-frontend/node_modules/schema-utils/LICENSE
===================================================================
--- imaps-frontend/node_modules/schema-utils/LICENSE	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/LICENSE	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -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.
Index: imaps-frontend/node_modules/schema-utils/README.md
===================================================================
--- imaps-frontend/node_modules/schema-utils/README.md	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/README.md	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,317 @@
+<div align="center">
+  <a href="http://json-schema.org">
+    <img width="160" height="160"
+      src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
+  </a>
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![GitHub Discussions][discussion]][discussion-url]
+[![size][size]][size-url]
+
+# schema-utils
+
+Package for validate options in loaders and plugins.
+
+## Getting Started
+
+To begin, you'll need to install `schema-utils`:
+
+```console
+npm install schema-utils
+```
+
+## API
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "option": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { option: true };
+const configuration = { name: "Loader Name/Plugin Name/Name" };
+
+validate(schema, options, configuration);
+```
+
+### `schema`
+
+Type: `String`
+
+JSON schema.
+
+Simple example of schema:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `options`
+
+Type: `Object`
+
+Object with options.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, { name: 123 }, { name: "MyPlugin" });
+```
+
+### `configuration`
+
+Allow to configure validator.
+
+There is an alternative method to configure the `name` and`baseDataPath` options via the `title` property in the schema.
+For example:
+
+```json
+{
+  "title": "My Loader options",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+The last word used for the `baseDataPath` option, other words used for the `name` option.
+Based on the example above the `name` option equals `My Loader`, the `baseDataPath` option equals `options`.
+
+#### `name`
+
+Type: `Object`
+Default: `"Object"`
+
+Allow to setup name in validation errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, { name: "MyPlugin" });
+```
+
+```shell
+Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
+ - configuration.optionName should be a integer.
+```
+
+#### `baseDataPath`
+
+Type: `String`
+Default: `"configuration"`
+
+Allow to setup base data path in validation errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, { name: "MyPlugin", baseDataPath: "options" });
+```
+
+```shell
+Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+```
+
+#### `postFormatter`
+
+Type: `Function`
+Default: `undefined`
+
+Allow to reformat errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, {
+  name: "MyPlugin",
+  postFormatter: (formattedError, error) => {
+    if (error.keyword === "type") {
+      return `${formattedError}\nAdditional Information.`;
+    }
+
+    return formattedError;
+  },
+});
+```
+
+```shell
+Invalid options object. MyPlugin has been initialized using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+   Additional Information.
+```
+
+## Examples
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "test": {
+      "anyOf": [
+        { "type": "array" },
+        { "type": "string" },
+        { "instanceof": "RegExp" }
+      ]
+    },
+    "transform": {
+      "instanceof": "Function"
+    },
+    "sourceMap": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `Loader`
+
+```js
+import { getOptions } from "loader-utils";
+import { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+function loader(src, map) {
+  const options = getOptions(this);
+
+  validate(schema, options, {
+    name: "Loader Name",
+    baseDataPath: "options",
+  });
+
+  // Code...
+}
+
+export default loader;
+```
+
+### `Plugin`
+
+```js
+import { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+class Plugin {
+  constructor(options) {
+    validate(schema, options, {
+      name: "Plugin Name",
+      baseDataPath: "options",
+    });
+
+    this.options = options;
+  }
+
+  apply(compiler) {
+    // Code...
+  }
+}
+
+export default Plugin;
+```
+
+### Allow to disable and enable validation (the `validate` function do nothing)
+
+This can be useful when you don't want to do validation for `production` builds.
+
+```js
+import { disableValidation, enableValidation, validate } from "schema-utils";
+
+// Disable validation
+disableValidation();
+// Do nothing
+validate(schema, options);
+
+// Enable validation
+enableValidation();
+// Will throw an error if schema is not valid
+validate(schema, options);
+
+// Allow to undestand do you need validation or not
+const need = needValidate();
+
+console.log(need);
+```
+
+Also you can enable/disable validation using the `process.env.SKIP_VALIDATION` env variable.
+
+Supported values (case insensitive):
+
+- `yes`/`y`/`true`/`1`/`on`
+- `no`/`n`/`false`/`0`/`off`
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/schema-utils.svg
+[npm-url]: https://npmjs.com/package/schema-utils
+[node]: https://img.shields.io/node/v/schema-utils.svg
+[node-url]: https://nodejs.org
+[tests]: https://github.com/webpack/schema-utils/workflows/schema-utils/badge.svg
+[tests-url]: https://github.com/webpack/schema-utils/actions
+[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/schema-utils
+[discussion]: https://img.shields.io/github/discussions/webpack/webpack
+[discussion-url]: https://github.com/webpack/webpack/discussions
+[size]: https://packagephobia.com/badge?p=schema-utils
+[size-url]: https://packagephobia.com/result?p=schema-utils
Index: imaps-frontend/node_modules/schema-utils/declarations/ValidationError.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/ValidationError.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/ValidationError.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,74 @@
+export default ValidationError;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type Schema = import("./validate").Schema;
+export type ValidationErrorConfiguration =
+  import("./validate").ValidationErrorConfiguration;
+export type PostFormatter = import("./validate").PostFormatter;
+export type SchemaUtilErrorObject = import("./validate").SchemaUtilErrorObject;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: Array<SchemaUtilErrorObject>,
+    schema: Schema,
+    configuration?: ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<Object>
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}
Index: imaps-frontend/node_modules/schema-utils/declarations/index.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/index.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/index.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,12 @@
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+import { enableValidation } from "./validate";
+import { disableValidation } from "./validate";
+import { needValidate } from "./validate";
+export {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate,
+};
Index: imaps-frontend/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,11 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import("ajv").default;
+export type SchemaValidateFunction = import("ajv").SchemaValidateFunction;
+export type AnySchemaObject = import("ajv").AnySchemaObject;
+export type SchemaUtilErrorObject = import("../validate").SchemaUtilErrorObject;
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;
Index: imaps-frontend/node_modules/schema-utils/declarations/keywords/limit.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/keywords/limit.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/keywords/limit.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,14 @@
+export default addLimitKeyword;
+export type Ajv = import("ajv").default;
+export type Code = import("ajv").Code;
+export type Name = import("ajv").Name;
+export type KeywordErrorDefinition = import("ajv").KeywordErrorDefinition;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").Code} Code */
+/** @typedef {import("ajv").Name} Name */
+/** @typedef {import("ajv").KeywordErrorDefinition} KeywordErrorDefinition */
+/**
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addLimitKeyword(ajv: Ajv): Ajv;
Index: imaps-frontend/node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,15 @@
+export default addUndefinedAsNullKeyword;
+export type Ajv = import("ajv").default;
+export type SchemaValidateFunction = import("ajv").SchemaValidateFunction;
+export type AnySchemaObject = import("ajv").AnySchemaObject;
+export type ValidateFunction = import("ajv").ValidateFunction;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addUndefinedAsNullKeyword(ajv: Ajv): Ajv;
Index: imaps-frontend/node_modules/schema-utils/declarations/util/Range.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/util/Range.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/util/Range.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,79 @@
+export = Range;
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+declare class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(
+    side: "left" | "right",
+    exclusive: boolean
+  ): ">" | ">=" | "<" | "<=";
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatRight(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatLeft(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+  static formatRange(
+    start: number,
+    end: number,
+    startExclusive: boolean,
+    endExclusive: boolean,
+    logic: boolean
+  ): string;
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+  static getRangeValue(values: Array<RangeValue>, logic: boolean): RangeValue;
+  /** @type {Array<RangeValue>} */
+  _left: Array<RangeValue>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<RangeValue>;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic?: boolean): string;
+}
+declare namespace Range {
+  export { RangeValue, RangeValueCallback };
+}
+type RangeValue = [number, boolean];
+type RangeValueCallback = (rangeValue: RangeValue) => boolean;
Index: imaps-frontend/node_modules/schema-utils/declarations/util/hints.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/util/hints.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/util/hints.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,3 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema = import("../validate").Schema;
Index: imaps-frontend/node_modules/schema-utils/declarations/util/memorize.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/util/memorize.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/util/memorize.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,7 @@
+export default memoize;
+/**
+ * @template T
+ * @param fn {(function(): any) | undefined}
+ * @returns {function(): T}
+ */
+declare function memoize<T>(fn: (() => any) | undefined): () => T;
Index: imaps-frontend/node_modules/schema-utils/declarations/validate.d.ts
===================================================================
--- imaps-frontend/node_modules/schema-utils/declarations/validate.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/declarations/validate.d.ts	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,41 @@
+export type JSONSchema4 = import("json-schema").JSONSchema4;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type ErrorObject = import("ajv").ErrorObject;
+export type Extend = {
+  formatMinimum?: (string | number) | undefined;
+  formatMaximum?: (string | number) | undefined;
+  formatExclusiveMinimum?: (string | boolean) | undefined;
+  formatExclusiveMaximum?: (string | boolean) | undefined;
+  link?: string | undefined;
+  undefinedAsNull?: boolean | undefined;
+};
+export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
+export type SchemaUtilErrorObject = ErrorObject & {
+  children?: Array<ErrorObject>;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+export function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+export function enableValidation(): void;
+export function disableValidation(): void;
+export function needValidate(): boolean;
+import ValidationError from "./ValidationError";
+export { ValidationError };
Index: imaps-frontend/node_modules/schema-utils/dist/ValidationError.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/ValidationError.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/ValidationError.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,1063 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _memorize = _interopRequireDefault(require("./util/memorize"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("./validate").Schema} Schema */
+/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
+/** @typedef {import("./validate").PostFormatter} PostFormatter */
+/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/** @enum {number} */
+const SPECIFICITY = {
+  type: 1,
+  not: 1,
+  oneOf: 1,
+  anyOf: 1,
+  if: 1,
+  enum: 1,
+  const: 1,
+  instanceof: 1,
+  required: 2,
+  pattern: 2,
+  patternRequired: 2,
+  format: 2,
+  formatMinimum: 2,
+  formatMaximum: 2,
+  minimum: 2,
+  exclusiveMinimum: 2,
+  maximum: 2,
+  exclusiveMaximum: 2,
+  multipleOf: 2,
+  uniqueItems: 2,
+  contains: 2,
+  minLength: 2,
+  maxLength: 2,
+  minItems: 2,
+  maxItems: 2,
+  minProperties: 2,
+  maxProperties: 2,
+  dependencies: 2,
+  propertyNames: 2,
+  additionalItems: 2,
+  additionalProperties: 2,
+  absolutePath: 2
+};
+
+/**
+ * @param {string} value
+ * @returns {value is number}
+ */
+function isNumeric(value) {
+  return /^-?\d+$/.test(value);
+}
+
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} array
+ * @param {(item: SchemaUtilErrorObject) => number} fn
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+function filterMax(array, fn) {
+  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
+  return array.filter(item => fn(item) === evaluatedMax);
+}
+
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+function filterChildren(children) {
+  let newChildren = children;
+  newChildren = filterMax(newChildren,
+  /**
+   *
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => error.instancePath ? error.instancePath.length : 0);
+  newChildren = filterMax(newChildren,
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => SPECIFICITY[(/** @type {keyof typeof SPECIFICITY} */error.keyword)] || 2);
+  return newChildren;
+}
+
+/**
+ * Find all children errors
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @param {Array<string>} schemaPaths
+ * @return {number} returns index of first child
+ */
+function findAllChildren(children, schemaPaths) {
+  let i = children.length - 1;
+  const predicate =
+  /**
+   * @param {string} schemaPath
+   * @returns {boolean}
+   */
+  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
+  while (i > -1 && !schemaPaths.every(predicate)) {
+    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
+      const refs = extractRefs(children[i]);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
+      i = childrenStart - 1;
+    } else {
+      i -= 1;
+    }
+  }
+  return i + 1;
+}
+
+/**
+ * Extracts all refs from schema
+ * @param {SchemaUtilErrorObject} error
+ * @return {Array<string>}
+ */
+function extractRefs(error) {
+  const {
+    schema
+  } = error;
+  if (!Array.isArray(schema)) {
+    return [];
+  }
+  return schema.map(({
+    $ref
+  }) => $ref).filter(s => s);
+}
+
+/**
+ * Groups children by their first level parent (assuming that error is root)
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @return {Array<SchemaUtilErrorObject>}
+ */
+function groupChildrenByFirstChild(children) {
+  const result = [];
+  let i = children.length - 1;
+  while (i > 0) {
+    const child = children[i];
+    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
+      const refs = extractRefs(child);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
+      if (childrenStart !== i) {
+        result.push(Object.assign({}, child, {
+          children: children.slice(childrenStart, i)
+        }));
+        i = childrenStart;
+      } else {
+        result.push(child);
+      }
+    } else {
+      result.push(child);
+    }
+    i -= 1;
+  }
+  if (i === 0) {
+    result.push(children[i]);
+  }
+  return result.reverse();
+}
+
+/**
+ * @param {string} str
+ * @param {string} prefix
+ * @returns {string}
+ */
+function indent(str, prefix) {
+  return str.replace(/\n(?!$)/g, `\n${prefix}`);
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {schema is (Schema & {not: Schema})}
+ */
+function hasNotInSchema(schema) {
+  return !!schema.not;
+}
+
+/**
+ * @param {Schema} schema
+ * @return {Schema}
+ */
+function findFirstTypedSchema(schema) {
+  if (hasNotInSchema(schema)) {
+    return findFirstTypedSchema(schema.not);
+  }
+  return schema;
+}
+
+/**
+ * @param {Schema} schema
+ * @return {boolean}
+ */
+function canApplyNot(schema) {
+  const typedSchema = findFirstTypedSchema(schema);
+  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
+}
+
+/**
+ * @param {any} maybeObj
+ * @returns {boolean}
+ */
+function isObject(maybeObj) {
+  return typeof maybeObj === "object" && !Array.isArray(maybeObj) && maybeObj !== null;
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeNumber(schema) {
+  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeInteger(schema) {
+  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeString(schema) {
+  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeBoolean(schema) {
+  return schema.type === "boolean";
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeArray(schema) {
+  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
+}
+
+/**
+ * @param {Schema & {patternRequired?: Array<string>}} schema
+ * @returns {boolean}
+ */
+function likeObject(schema) {
+  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
+}
+
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
+function likeNull(schema) {
+  return schema.type === "null";
+}
+
+/**
+ * @param {string} type
+ * @returns {string}
+ */
+function getArticle(type) {
+  if (/^[aeiou]/i.test(type)) {
+    return "an";
+  }
+  return "a";
+}
+
+/**
+ * @param {Schema=} schema
+ * @returns {string}
+ */
+function getSchemaNonTypes(schema) {
+  if (!schema) {
+    return "";
+  }
+  if (!schema.type) {
+    if (likeNumber(schema) || likeInteger(schema)) {
+      return " | should be any non-number";
+    }
+    if (likeString(schema)) {
+      return " | should be any non-string";
+    }
+    if (likeArray(schema)) {
+      return " | should be any non-array";
+    }
+    if (likeObject(schema)) {
+      return " | should be any non-object";
+    }
+  }
+  return "";
+}
+
+/**
+ * @param {Array<string>} hints
+ * @returns {string}
+ */
+function formatHints(hints) {
+  return hints.length > 0 ? `(${hints.join(", ")})` : "";
+}
+const getUtilHints = (0, _memorize.default)(() =>
+// eslint-disable-next-line global-require
+require("./util/hints"));
+
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @returns {string[]}
+ */
+function getHints(schema, logic) {
+  if (likeNumber(schema) || likeInteger(schema)) {
+    const util = getUtilHints();
+    return util.numberHints(schema, logic);
+  } else if (likeString(schema)) {
+    const util = getUtilHints();
+    return util.stringHints(schema, logic);
+  }
+  return [];
+}
+class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(errors, schema, configuration = {}) {
+    super();
+
+    /** @type {string} */
+    this.name = "ValidationError";
+    /** @type {Array<SchemaUtilErrorObject>} */
+    this.errors = errors;
+    /** @type {Schema} */
+    this.schema = schema;
+    let headerNameFromSchema;
+    let baseDataPathFromSchema;
+    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
+      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
+      if (splittedTitleFromSchema) {
+        if (!configuration.name) {
+          [, headerNameFromSchema] = splittedTitleFromSchema;
+        }
+        if (!configuration.baseDataPath) {
+          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
+        }
+      }
+    }
+
+    /** @type {string} */
+    this.headerName = configuration.name || headerNameFromSchema || "Object";
+    /** @type {string} */
+    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
+
+    /** @type {PostFormatter | null} */
+    this.postFormatter = configuration.postFormatter || null;
+    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
+
+    /** @type {string} */
+    this.message = `${header}${this.formatValidationErrors(errors)}`;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path) {
+    const newPath = path.split("/");
+    let schemaPart = this.schema;
+    for (let i = 1; i < newPath.length; i++) {
+      const inner = schemaPart[(/** @type {keyof Schema} */newPath[i])];
+      if (!inner) {
+        break;
+      }
+      schemaPart = inner;
+    }
+    return schemaPart;
+  }
+
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(schema, logic = true, prevSchemas = []) {
+    let newLogic = logic;
+    const formatInnerSchema =
+    /**
+     *
+     * @param {Object} innerSchema
+     * @param {boolean=} addSelf
+     * @returns {string}
+     */
+    (innerSchema, addSelf) => {
+      if (!addSelf) {
+        return this.formatSchema(innerSchema, newLogic, prevSchemas);
+      }
+      if (prevSchemas.includes(innerSchema)) {
+        return "(recursive)";
+      }
+      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
+    };
+    if (hasNotInSchema(schema) && !likeObject(schema)) {
+      if (canApplyNot(schema.not)) {
+        newLogic = !logic;
+        return formatInnerSchema(schema.not);
+      }
+      const needApplyLogicHere = !schema.not.not;
+      const prefix = logic ? "" : "non ";
+      newLogic = !logic;
+      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
+    }
+    if (/** @type {Schema & {instanceof: string | Array<string>}} */schema.instanceof) {
+      const {
+        instanceof: value
+      } = /** @type {Schema & {instanceof: string | Array<string>}} */schema;
+      const values = !Array.isArray(value) ? [value] : value;
+      return values.map(
+      /**
+       * @param {string} item
+       * @returns {string}
+       */
+      item => item === "Function" ? "function" : item).join(" | ");
+    }
+    if (schema.enum) {
+      const enumValues = /** @type {Array<any>} */schema.enum.map(item => {
+        if (item === null && schema.undefinedAsNull) {
+          return `${JSON.stringify(item)} | undefined`;
+        }
+        return JSON.stringify(item);
+      }).join(" | ");
+      return `${enumValues}`;
+    }
+    if (typeof schema.const !== "undefined") {
+      return JSON.stringify(schema.const);
+    }
+    if (schema.oneOf) {
+      return /** @type {Array<Schema>} */schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ");
+    }
+    if (schema.anyOf) {
+      return /** @type {Array<Schema>} */schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ");
+    }
+    if (schema.allOf) {
+      return /** @type {Array<Schema>} */schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ");
+    }
+    if (/** @type {JSONSchema7} */schema.if) {
+      const {
+        if: ifValue,
+        then: thenValue,
+        else: elseValue
+      } = /** @type {JSONSchema7} */schema;
+      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
+    }
+    if (schema.$ref) {
+      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
+    }
+    if (likeNumber(schema) || likeInteger(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
+    }
+    if (likeString(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
+    }
+    if (likeBoolean(schema)) {
+      return `${logic ? "" : "non-"}boolean`;
+    }
+    if (likeArray(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
+      if (typeof schema.minItems === "number") {
+        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
+      }
+      if (typeof schema.maxItems === "number") {
+        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
+      }
+      if (schema.uniqueItems) {
+        hints.push("should not have duplicate items");
+      }
+      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
+      let items = "";
+      if (schema.items) {
+        if (Array.isArray(schema.items) && schema.items.length > 0) {
+          items = `${/** @type {Array<Schema>} */schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
+          if (hasAdditionalItems) {
+            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
+              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
+            }
+          }
+        } else if (schema.items && Object.keys(schema.items).length > 0) {
+          // "additionalItems" is ignored
+          items = `${formatInnerSchema(schema.items)}`;
+        } else {
+          // Fallback for empty `items` value
+          items = "any";
+        }
+      } else {
+        // "additionalItems" is ignored
+        items = "any";
+      }
+      if (schema.contains && Object.keys(schema.contains).length > 0) {
+        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
+      }
+      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+    }
+    if (likeObject(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
+      if (typeof schema.minProperties === "number") {
+        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
+      }
+      if (typeof schema.maxProperties === "number") {
+        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
+      }
+      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
+        const patternProperties = Object.keys(schema.patternProperties);
+        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
+      }
+      const properties = schema.properties ? Object.keys(schema.properties) : [];
+      /** @type {Array<string>} */
+      // @ts-ignore
+      const required = schema.required ? schema.required : [];
+      const allProperties = [...new Set(/** @type {Array<string>} */[].concat(required).concat(properties))];
+      const objectStructure = allProperties.map(property => {
+        const isRequired = required.includes(property);
+
+        // Some properties need quotes, maybe we should add check
+        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
+        return `${property}${isRequired ? "" : "?"}`;
+      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
+      const {
+        dependencies,
+        propertyNames,
+        patternRequired
+      } = /** @type {Schema & {patternRequired?: Array<string>;}} */schema;
+      if (dependencies) {
+        Object.keys(dependencies).forEach(dependencyName => {
+          const dependency = dependencies[dependencyName];
+          if (Array.isArray(dependency)) {
+            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
+          } else {
+            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
+          }
+        });
+      }
+      if (propertyNames && Object.keys(propertyNames).length > 0) {
+        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
+      }
+      if (patternRequired && patternRequired.length > 0) {
+        hints.push(`should have property matching pattern ${patternRequired.map(
+        /**
+         * @param {string} item
+         * @returns {string}
+         */
+        item => JSON.stringify(item))}`);
+      }
+      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+    }
+    if (likeNull(schema)) {
+      return `${logic ? "" : "non-"}null`;
+    }
+    if (Array.isArray(schema.type)) {
+      // not logic already applied in formatValidationError
+      return `${schema.type.join(" | ")}`;
+    }
+
+    // Fallback for unknown keywords
+    // not logic already applied in formatValidationError
+    /* istanbul ignore next */
+    return JSON.stringify(schema, null, 2);
+  }
+
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
+    if (!schemaPart) {
+      return "";
+    }
+    if (Array.isArray(additionalPath)) {
+      for (let i = 0; i < additionalPath.length; i++) {
+        /** @type {Schema | undefined} */
+        const inner = schemaPart[(/** @type {keyof Schema} */additionalPath[i])];
+        if (inner) {
+          // eslint-disable-next-line no-param-reassign
+          schemaPart = inner;
+        } else {
+          break;
+        }
+      }
+    }
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
+    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
+    }
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
+    return schemaText;
+  }
+
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart) {
+    if (!schemaPart) {
+      return "";
+    }
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
+    let schemaText = "";
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
+    }
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
+    return schemaText;
+  }
+
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error) {
+    const {
+      keyword,
+      instancePath: errorInstancePath
+    } = error;
+    const splittedInstancePath = errorInstancePath.split("/");
+    /**
+     * @type {Array<string>}
+     */
+    const defaultValue = [];
+    const prettyInstancePath = splittedInstancePath.reduce((acc, val) => {
+      if (val.length > 0) {
+        if (isNumeric(val)) {
+          acc.push(`[${val}]`);
+        } else if (/^\[/.test(val)) {
+          acc.push(val);
+        } else {
+          acc.push(`.${val}`);
+        }
+      }
+      return acc;
+    }, defaultValue).join("");
+    const instancePath = `${this.baseDataPath}${prettyInstancePath}`;
+
+    // const { keyword, instancePath: errorInstancePath } = error;
+    // const instancePath = `${this.baseDataPath}${errorInstancePath.replace(/\//g, '.')}`;
+
+    switch (keyword) {
+      case "type":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          switch (params.type) {
+            case "number":
+              return `${instancePath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+            case "integer":
+              return `${instancePath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
+            case "string":
+              return `${instancePath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+            case "boolean":
+              return `${instancePath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+            case "array":
+              return `${instancePath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
+            case "object":
+              return `${instancePath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
+            case "null":
+              return `${instancePath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+            default:
+              return `${instancePath} should be:\n${this.getSchemaPartText(parentSchema)}`;
+          }
+        }
+      case "instanceof":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${instancePath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
+      case "pattern":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            pattern
+          } = params;
+          return `${instancePath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "format":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            format
+          } = params;
+          return `${instancePath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "formatMinimum":
+      case "formatExclusiveMinimum":
+      case "formatMaximum":
+      case "formatExclusiveMaximum":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            comparison,
+            limit
+          } = params;
+          return `${instancePath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "minimum":
+      case "maximum":
+      case "exclusiveMinimum":
+      case "exclusiveMaximum":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const {
+            comparison,
+            limit
+          } = params;
+          const [, ...hints] = getHints(/** @type {Schema} */parentSchema, true);
+          if (hints.length === 0) {
+            hints.push(`should be ${comparison} ${limit}`);
+          }
+          return `${instancePath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "multipleOf":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            multipleOf
+          } = params;
+          return `${instancePath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "patternRequired":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            missingPattern
+          } = params;
+          return `${instancePath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "minLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          if (limit === 1) {
+            return `${instancePath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
+          const length = limit - 1;
+          return `${instancePath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "minItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          if (limit === 1) {
+            return `${instancePath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
+          return `${instancePath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "minProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          if (limit === 1) {
+            return `${instancePath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
+          return `${instancePath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "maxLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          const max = limit + 1;
+          return `${instancePath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "maxItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          return `${instancePath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "maxProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          return `${instancePath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "uniqueItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            i
+          } = params;
+          return `${instancePath} should not contain the item '${/** @type {{ data: Array<any> }} **/
+          error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "additionalItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } = params;
+          return `${instancePath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
+        }
+      case "contains":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${instancePath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
+        }
+      case "required":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const missingProperty = params.missingProperty.replace(/^\./, "");
+          const hasProperty = parentSchema && Boolean(/** @type {Schema} */
+          parentSchema.properties && /** @type {Schema} */
+          parentSchema.properties[missingProperty]);
+          return `${instancePath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "additionalProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            additionalProperty
+          } = params;
+          return `${instancePath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
+        }
+      case "dependencies":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            property,
+            deps
+          } = params;
+          const dependencies = deps.split(",").map(
+          /**
+           * @param {string} dep
+           * @returns {string}
+           */
+          dep => `'${dep.trim()}'`).join(", ");
+          return `${instancePath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "propertyNames":
+        {
+          const {
+            params,
+            parentSchema,
+            schema
+          } = error;
+          const {
+            propertyName
+          } = params;
+          return `${instancePath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      case "enum":
+        {
+          const {
+            parentSchema
+          } = error;
+          if (parentSchema && /** @type {Schema} */
+          parentSchema.enum && /** @type {Schema} */
+          parentSchema.enum.length === 1) {
+            return `${instancePath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
+          }
+          return `${instancePath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
+      case "const":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${instancePath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
+      case "not":
+        {
+          const postfix = likeObject(/** @type {Schema} */error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
+          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
+          if (canApplyNot(error.schema)) {
+            return `${instancePath} should be any ${schemaOutput}${postfix}.`;
+          }
+          const {
+            schema,
+            parentSchema
+          } = error;
+          return `${instancePath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
+        }
+      case "oneOf":
+      case "anyOf":
+        {
+          const {
+            parentSchema,
+            children
+          } = error;
+          if (children && children.length > 0) {
+            if (error.schema.length === 1) {
+              const lastChild = children[children.length - 1];
+              const remainingChildren = children.slice(0, children.length - 1);
+              return this.formatValidationError(Object.assign({}, lastChild, {
+                children: remainingChildren,
+                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
+              }));
+            }
+            let filteredChildren = filterChildren(children);
+            if (filteredChildren.length === 1) {
+              return this.formatValidationError(filteredChildren[0]);
+            }
+            filteredChildren = groupChildrenByFirstChild(filteredChildren);
+            return `${instancePath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
+            /**
+             * @param {SchemaUtilErrorObject} nestedError
+             * @returns {string}
+             */
+            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
+          }
+          return `${instancePath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
+      case "if":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            failingKeyword
+          } = params;
+          return `${instancePath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
+        }
+      case "absolutePath":
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          return `${instancePath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
+        }
+      /* istanbul ignore next */
+      default:
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          const ErrorInJSON = JSON.stringify(error, null, 2);
+
+          // For `custom`, `false schema`, `$ref` keywords
+          // Fallback for unknown keywords
+          return `${instancePath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
+        }
+    }
+  }
+
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors) {
+    return errors.map(error => {
+      let formattedError = this.formatValidationError(error);
+      if (this.postFormatter) {
+        formattedError = this.postFormatter(formattedError, error);
+      }
+      return ` - ${indent(formattedError, "   ")}`;
+    }).join("\n");
+  }
+}
+var _default = exports.default = ValidationError;
Index: imaps-frontend/node_modules/schema-utils/dist/index.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/index.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,16 @@
+"use strict";
+
+const {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+} = require("./validate");
+module.exports = {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+};
Index: imaps-frontend/node_modules/schema-utils/dist/keywords/absolutePath.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/keywords/absolutePath.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/keywords/absolutePath.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/**
+ * @param {string} message
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+function errorMessage(message, schema, data) {
+  return {
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    dataPath: undefined,
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    schemaPath: undefined,
+    keyword: "absolutePath",
+    params: {
+      absolutePath: data
+    },
+    message,
+    parentSchema: schema
+  };
+}
+
+/**
+ * @param {boolean} shouldBeAbsolute
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+function getErrorFor(shouldBeAbsolute, schema, data) {
+  const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
+  return errorMessage(message, schema, data);
+}
+
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+function addAbsolutePathKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: "absolutePath",
+    type: "string",
+    errors: true,
+    /**
+     * @param {boolean} schema
+     * @param {AnySchemaObject} parentSchema
+     * @returns {SchemaValidateFunction}
+     */
+    compile(schema, parentSchema) {
+      /** @type {SchemaValidateFunction} */
+      const callback = data => {
+        let passes = true;
+        const isExclamationMarkPresent = data.includes("!");
+        if (isExclamationMarkPresent) {
+          callback.errors = [errorMessage(`The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`, parentSchema, data)];
+          passes = false;
+        }
+
+        // ?:[A-Za-z]:\\ - Windows absolute path
+        // \\\\ - Windows network absolute path
+        // \/ - Unix-like OS absolute path
+        const isCorrectAbsolutePath = schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);
+        if (!isCorrectAbsolutePath) {
+          callback.errors = [getErrorFor(schema, parentSchema, data)];
+          passes = false;
+        }
+        return passes;
+      };
+      callback.errors = [];
+      return callback;
+    }
+  });
+  return ajv;
+}
+var _default = exports.default = addAbsolutePathKeyword;
Index: imaps-frontend/node_modules/schema-utils/dist/keywords/limit.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/keywords/limit.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/keywords/limit.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").Code} Code */
+/** @typedef {import("ajv").Name} Name */
+/** @typedef {import("ajv").KeywordErrorDefinition} KeywordErrorDefinition */
+
+/**
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+function addLimitKeyword(ajv) {
+  // eslint-disable-next-line global-require
+  const {
+    _,
+    str,
+    KeywordCxt,
+    nil,
+    Name
+  } = require("ajv");
+
+  /**
+   * @param {Code | Name} x
+   * @returns {Code | Name}
+   */
+  function par(x) {
+    return x instanceof Name ? x : _`(${x})`;
+  }
+
+  /**
+   * @param {Code} op
+   * @returns {function(Code, Code): Code}
+   */
+  function mappend(op) {
+    return (x, y) => x === nil ? y : y === nil ? x : _`${par(x)} ${op} ${par(y)}`;
+  }
+  const orCode = mappend(_`||`);
+
+  // boolean OR (||) expression with the passed arguments
+  /**
+   * @param {...Code} args
+   * @returns {Code}
+   */
+  function or(...args) {
+    return args.reduce(orCode);
+  }
+
+  /**
+   * @param {string | number} key
+   * @returns {Code}
+   */
+  function getProperty(key) {
+    return _`[${key}]`;
+  }
+  const keywords = {
+    formatMaximum: {
+      okStr: "<=",
+      ok: _`<=`,
+      fail: _`>`
+    },
+    formatMinimum: {
+      okStr: ">=",
+      ok: _`>=`,
+      fail: _`<`
+    },
+    formatExclusiveMaximum: {
+      okStr: "<",
+      ok: _`<`,
+      fail: _`>=`
+    },
+    formatExclusiveMinimum: {
+      okStr: ">",
+      ok: _`>`,
+      fail: _`<=`
+    }
+  };
+
+  /** @type {KeywordErrorDefinition} */
+  const error = {
+    message: ({
+      keyword,
+      schemaCode
+    }) => str`should be ${keywords[(/** @type {keyof typeof keywords} */keyword)].okStr} ${schemaCode}`,
+    params: ({
+      keyword,
+      schemaCode
+    }) => _`{comparison: ${keywords[(/** @type {keyof typeof keywords} */keyword)].okStr}, limit: ${schemaCode}}`
+  };
+  for (const keyword of Object.keys(keywords)) {
+    ajv.addKeyword({
+      keyword,
+      type: "string",
+      schemaType: keyword.startsWith("formatExclusive") ? ["string", "boolean"] : ["string", "number"],
+      $data: true,
+      error,
+      code(cxt) {
+        const {
+          gen,
+          data,
+          schemaCode,
+          keyword,
+          it
+        } = cxt;
+        const {
+          opts,
+          self
+        } = it;
+        if (!opts.validateFormats) return;
+        const fCxt = new KeywordCxt(it, /** @type {any} */
+        self.RULES.all.format.definition, "format");
+
+        /**
+         * @param {Name} fmt
+         * @returns {Code}
+         */
+        function compareCode(fmt) {
+          return _`${fmt}.compare(${data}, ${schemaCode}) ${keywords[(/** @type {keyof typeof keywords} */keyword)].fail} 0`;
+        }
+        function validate$DataFormat() {
+          const fmts = gen.scopeValue("formats", {
+            ref: self.formats,
+            code: opts.code.formats
+          });
+          const fmt = gen.const("fmt", _`${fmts}[${fCxt.schemaCode}]`);
+          cxt.fail$data(or(_`typeof ${fmt} != "object"`, _`${fmt} instanceof RegExp`, _`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
+        }
+        function validateFormat() {
+          const format = fCxt.schema;
+          const fmtDef = self.formats[format];
+          if (!fmtDef || fmtDef === true) {
+            return;
+          }
+          if (typeof fmtDef !== "object" || fmtDef instanceof RegExp || typeof fmtDef.compare !== "function") {
+            throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
+          }
+          const fmt = gen.scopeValue("formats", {
+            key: format,
+            ref: fmtDef,
+            code: opts.code.formats ? _`${opts.code.formats}${getProperty(format)}` : undefined
+          });
+          cxt.fail$data(compareCode(fmt));
+        }
+        if (fCxt.$data) {
+          validate$DataFormat();
+        } else {
+          validateFormat();
+        }
+      },
+      dependencies: ["format"]
+    });
+  }
+  return ajv;
+}
+var _default = exports.default = addLimitKeyword;
Index: imaps-frontend/node_modules/schema-utils/dist/keywords/undefinedAsNull.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/keywords/undefinedAsNull.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/keywords/undefinedAsNull.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/** @typedef {import("ajv").default} Ajv */
+/** @typedef {import("ajv").SchemaValidateFunction} SchemaValidateFunction */
+/** @typedef {import("ajv").AnySchemaObject} AnySchemaObject */
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+function addUndefinedAsNullKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: "undefinedAsNull",
+    before: "enum",
+    modifying: true,
+    /** @type {SchemaValidateFunction} */
+    validate(kwVal, data, metadata, dataCxt) {
+      if (kwVal && dataCxt && metadata && typeof metadata.enum !== "undefined") {
+        const idx = dataCxt.parentDataProperty;
+        if (typeof dataCxt.parentData[idx] === "undefined") {
+          // eslint-disable-next-line no-param-reassign
+          dataCxt.parentData[dataCxt.parentDataProperty] = null;
+        }
+      }
+      return true;
+    }
+  });
+  return ajv;
+}
+var _default = exports.default = addUndefinedAsNullKeyword;
Index: imaps-frontend/node_modules/schema-utils/dist/util/Range.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/util/Range.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/util/Range.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,143 @@
+"use strict";
+
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === "left") {
+      return exclusive ? ">" : ">=";
+    }
+    return exclusive ? "<" : "<=";
+  }
+
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
+    }
+    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
+  }
+
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
+    }
+    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
+  }
+
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = "should be";
+    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? "and" : "or";
+    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ? /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax : /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
+    }
+    if (j > -1) {
+      return values[j];
+    }
+    return [Infinity, true];
+  }
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
+    this._right = [];
+  }
+
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return "";
+    }
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end;
+
+    // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+    if (realStart === realEnd) {
+      return `should be ${logic ? "" : "!"}= ${realStart}`;
+    }
+
+    // e.g. 4 < x < ∞
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    }
+
+    // e.g. ∞ < x < 4
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
+    }
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
+}
+module.exports = Range;
Index: imaps-frontend/node_modules/schema-utils/dist/util/hints.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/util/hints.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/util/hints.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,85 @@
+"use strict";
+
+const Range = require("./Range");
+
+/** @typedef {import("../validate").Schema} Schema */
+
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+module.exports.stringHints = function stringHints(schema, logic) {
+  const hints = [];
+  let type = "string";
+  const currentSchema = {
+    ...schema
+  };
+  if (!logic) {
+    const tmpLength = currentSchema.minLength;
+    const tmpFormat = currentSchema.formatMinimum;
+    currentSchema.minLength = currentSchema.maxLength;
+    currentSchema.maxLength = tmpLength;
+    currentSchema.formatMinimum = currentSchema.formatMaximum;
+    currentSchema.formatMaximum = tmpFormat;
+  }
+  if (typeof currentSchema.minLength === "number") {
+    if (currentSchema.minLength === 1) {
+      type = "non-empty string";
+    } else {
+      const length = Math.max(currentSchema.minLength - 1, 0);
+      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
+  if (typeof currentSchema.maxLength === "number") {
+    if (currentSchema.maxLength === 0) {
+      type = "empty string";
+    } else {
+      const length = currentSchema.maxLength + 1;
+      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
+  if (currentSchema.pattern) {
+    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
+  }
+  if (currentSchema.format) {
+    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
+  }
+  if (currentSchema.formatMinimum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
+  }
+  if (currentSchema.formatMaximum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
+  }
+  return [type].concat(hints);
+};
+
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+module.exports.numberHints = function numberHints(schema, logic) {
+  const hints = [schema.type === "integer" ? "integer" : "number"];
+  const range = new Range();
+  if (typeof schema.minimum === "number") {
+    range.left(schema.minimum);
+  }
+  if (typeof schema.exclusiveMinimum === "number") {
+    range.left(schema.exclusiveMinimum, true);
+  }
+  if (typeof schema.maximum === "number") {
+    range.right(schema.maximum);
+  }
+  if (typeof schema.exclusiveMaximum === "number") {
+    range.right(schema.exclusiveMaximum, true);
+  }
+  const rangeFormat = range.format(logic);
+  if (rangeFormat) {
+    hints.push(rangeFormat);
+  }
+  if (typeof schema.multipleOf === "number") {
+    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
+  }
+  return hints;
+};
Index: imaps-frontend/node_modules/schema-utils/dist/util/memorize.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/util/memorize.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/util/memorize.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * @template T
+ * @param fn {(function(): any) | undefined}
+ * @returns {function(): T}
+ */
+const memoize = fn => {
+  let cache = false;
+  /** @type {T} */
+  let result;
+  return () => {
+    if (cache) {
+      return result;
+    }
+    result = /** @type {function(): any} */fn();
+    cache = true;
+    // Allow to clean up memory for fn
+    // and all dependent resources
+    // eslint-disable-next-line no-undefined, no-param-reassign
+    fn = undefined;
+    return result;
+  };
+};
+var _default = exports.default = memoize;
Index: imaps-frontend/node_modules/schema-utils/dist/validate.js
===================================================================
--- imaps-frontend/node_modules/schema-utils/dist/validate.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/dist/validate.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.default;
+  }
+});
+exports.disableValidation = disableValidation;
+exports.enableValidation = enableValidation;
+exports.needValidate = needValidate;
+exports.validate = validate;
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+var _memorize = _interopRequireDefault(require("./util/memorize"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getAjv = (0, _memorize.default)(() => {
+  // Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
+  // eslint-disable-next-line global-require
+  const Ajv = require("ajv").default;
+  // eslint-disable-next-line global-require
+  const ajvKeywords = require("ajv-keywords").default;
+  // eslint-disable-next-line global-require
+  const addFormats = require("ajv-formats").default;
+
+  /**
+   * @type {Ajv}
+   */
+  const ajv = new Ajv({
+    strict: false,
+    allErrors: true,
+    verbose: true,
+    $data: true
+  });
+  ajvKeywords(ajv, ["instanceof", "patternRequired"]);
+  // TODO set `{ keywords: true }` for the next major release and remove `keywords/limit.js`
+  addFormats(ajv, {
+    keywords: false
+  });
+
+  // Custom keywords
+  // eslint-disable-next-line global-require
+  const addAbsolutePathKeyword = require("./keywords/absolutePath").default;
+  addAbsolutePathKeyword(ajv);
+
+  // eslint-disable-next-line global-require
+  const addLimitKeyword = require("./keywords/limit").default;
+  addLimitKeyword(ajv);
+  const addUndefinedAsNullKeyword =
+  // eslint-disable-next-line global-require
+  require("./keywords/undefinedAsNull").default;
+  addUndefinedAsNullKeyword(ajv);
+  return ajv;
+});
+
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/**
+ * @typedef {Object} Extend
+ * @property {(string | number)=} formatMinimum
+ * @property {(string | number)=} formatMaximum
+ * @property {(string | boolean)=} formatExclusiveMinimum
+ * @property {(string | boolean)=} formatExclusiveMaximum
+ * @property {string=} link
+ * @property {boolean=} undefinedAsNull
+ */
+
+/** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */
+
+/** @typedef {ErrorObject & { children?: Array<ErrorObject> }} SchemaUtilErrorObject */
+
+/**
+ * @callback PostFormatter
+ * @param {string} formattedError
+ * @param {SchemaUtilErrorObject} error
+ * @returns {string}
+ */
+
+/**
+ * @typedef {Object} ValidationErrorConfiguration
+ * @property {string=} name
+ * @property {string=} baseDataPath
+ * @property {PostFormatter=} postFormatter
+ */
+
+/**
+ * @param {SchemaUtilErrorObject} error
+ * @param {number} idx
+ * @returns {SchemaUtilErrorObject}
+ */
+function applyPrefix(error, idx) {
+  // eslint-disable-next-line no-param-reassign
+  error.instancePath = `[${idx}]${error.instancePath}`;
+  if (error.children) {
+    error.children.forEach(err => applyPrefix(err, idx));
+  }
+  return error;
+}
+let skipValidation = false;
+
+// We use `process.env.SKIP_VALIDATION` because you can have multiple `schema-utils` with different version,
+// so we want to disable it globally, `process.env` doesn't supported by browsers, so we have the local `skipValidation` variables
+
+// Enable validation
+function enableValidation() {
+  skipValidation = false;
+
+  // Disable validation for any versions
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "n";
+  }
+}
+
+// Disable validation
+function disableValidation() {
+  skipValidation = true;
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "y";
+  }
+}
+
+// Check if we need to confirm
+function needValidate() {
+  if (skipValidation) {
+    return false;
+  }
+  if (process && process.env && process.env.SKIP_VALIDATION) {
+    const value = process.env.SKIP_VALIDATION.trim();
+    if (/^(?:y|yes|true|1|on)$/i.test(value)) {
+      return false;
+    }
+    if (/^(?:n|no|false|0|off)$/i.test(value)) {
+      return true;
+    }
+  }
+  return true;
+}
+
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+function validate(schema, options, configuration) {
+  if (!needValidate()) {
+    return;
+  }
+  let errors = [];
+  if (Array.isArray(options)) {
+    for (let i = 0; i <= options.length - 1; i++) {
+      errors.push(...validateObject(schema, options[i]).map(err => applyPrefix(err, i)));
+    }
+  } else {
+    errors = validateObject(schema, options);
+  }
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+function validateObject(schema, options) {
+  // Not need to cache, because `ajv@8` has built-in cache
+  const compiledSchema = getAjv().compile(schema);
+  const valid = compiledSchema(options);
+  if (valid) return [];
+  return compiledSchema.errors ? filterErrors(compiledSchema.errors) : [];
+}
+
+/**
+ * @param {Array<ErrorObject>} errors
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+function filterErrors(errors) {
+  /** @type {Array<SchemaUtilErrorObject>} */
+  let newErrors = [];
+  for (const error of (/** @type {Array<SchemaUtilErrorObject>} */errors)) {
+    const {
+      instancePath
+    } = error;
+    /** @type {Array<SchemaUtilErrorObject>} */
+    let children = [];
+    newErrors = newErrors.filter(oldError => {
+      if (oldError.instancePath.includes(instancePath)) {
+        if (oldError.children) {
+          children = children.concat(oldError.children.slice(0));
+        }
+
+        // eslint-disable-next-line no-undefined, no-param-reassign
+        oldError.children = undefined;
+        children.push(oldError);
+        return false;
+      }
+      return true;
+    });
+    if (children.length) {
+      error.children = children;
+    }
+    newErrors.push(error);
+  }
+  return newErrors;
+}
Index: imaps-frontend/node_modules/schema-utils/package.json
===================================================================
--- imaps-frontend/node_modules/schema-utils/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/schema-utils/package.json	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,116 @@
+{
+  "_from": "schema-utils@^4.3.0",
+  "_id": "schema-utils@4.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==",
+  "_location": "/schema-utils",
+  "_phantomChildren": {
+    "fast-deep-equal": "3.1.3",
+    "fast-uri": "3.0.5",
+    "require-from-string": "2.0.2"
+  },
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "schema-utils@^4.3.0",
+    "name": "schema-utils",
+    "escapedName": "schema-utils",
+    "rawSpec": "^4.3.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.3.0"
+  },
+  "_requiredBy": [
+    "/terser-webpack-plugin"
+  ],
+  "_resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.0.tgz",
+  "_shasum": "3b669f04f71ff2dfb5aba7ce2d5a9d79b35622c0",
+  "_spec": "schema-utils@^4.3.0",
+  "_where": "/home/stevetosak/Proekt/IMaps/imaps-frontend/node_modules/terser-webpack-plugin",
+  "author": {
+    "name": "webpack Contrib",
+    "url": "https://github.com/webpack-contrib"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/schema-utils/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@types/json-schema": "^7.0.9",
+    "ajv": "^8.9.0",
+    "ajv-formats": "^2.1.1",
+    "ajv-keywords": "^5.1.0"
+  },
+  "deprecated": false,
+  "description": "webpack Validation Utils",
+  "devDependencies": {
+    "@babel/cli": "^7.17.0",
+    "@babel/core": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@commitlint/cli": "^17.6.1",
+    "@commitlint/config-conventional": "^16.0.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^27.4.6",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^4.0.1",
+    "eslint": "^8.8.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.4",
+    "husky": "^7.0.4",
+    "jest": "^27.4.7",
+    "lint-staged": "^13.2.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.5.1",
+    "standard-version": "^9.3.2",
+    "typescript": "^4.9.5",
+    "webpack": "^5.97.1"
+  },
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "homepage": "https://github.com/webpack/schema-utils",
+  "keywords": [
+    "webpack"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "name": "schema-utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/schema-utils.git"
+  },
+  "scripts": {
+    "build": "npm-run-all -p \"build:**\"",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "clean": "del-cli dist declarations",
+    "commitlint": "commitlint --from=master",
+    "fix": "npm-run-all fix:js fmt",
+    "fix:js": "npm run lint:js -- --fix",
+    "fmt": "npm run fmt:check -- --write",
+    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint": "npm-run-all lint:js lint:types fmt:check",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "prebuild": "npm run clean",
+    "prepare": "npm run build && husky install",
+    "pretest": "npm run lint",
+    "release": "standard-version",
+    "security": "npm audit --production",
+    "start": "npm run build -- -w",
+    "test": "npm run test:coverage",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch"
+  },
+  "types": "declarations/index.d.ts",
+  "version": "4.3.0"
+}
