schema-shield 0.0.3 → 0.0.5

package/README.md

@@ -13,8 +13,6 @@ Despite its feature-rich and easy extendable nature, SchemaShield is designed to
 - [Usage](#usage)
 - [No Code Generation](#no-code-generation)
 - [Error Handling](#error-handling)
-  - [ValidationError Properties](#validationerror-properties)
-  - [Get the cause of the error](#get-the-cause-of-the-error)
 - [Adding Custom Types](#adding-custom-types)
   - [Method Signature](#method-signature)
   - [Example: Adding a Custom Type](#example-adding-a-custom-type)
@@ -26,12 +24,16 @@ Despite its feature-rich and easy extendable nature, SchemaShield is designed to
   - [Example: Adding a Custom Keyword](#example-adding-a-custom-keyword)
   - [Complex example: Adding a Custom Keyword that uses the instance](#complex-example-adding-a-custom-keyword-that-uses-the-instance)
 - [No Code Generation Opened Possibilities](#no-code-generation-opened-possibilities)
+- [More on Error Handling](#more-on-error-handling)
+  - [ValidationError Properties](#validationerror-properties)
+  - [Get the path to the error location](#get-the-path-to-the-error-location)
+  - [Get the full error chain as a tree](#get-the-full-error-chain-as-a-tree)
+  - [Get the cause of the error](#get-the-cause-of-the-error)
 - [Immutable Mode](#immutable-mode)
 - [TypeScript Support](#typescript-support)
 - [Known Limitations](#known-limitations)
   - [Schema References and Schema Definitions](#schema-references-and-schema-definitions)
   - [Unsupported Formats](#unsupported-formats)
-  - [Internationalized Formats](#internationalized-formats)
 - [Testing](#testing)
 - [Contribute](#contribute)
 - [Legal](#legal)
@@ -44,6 +46,7 @@ Despite its feature-rich and easy extendable nature, SchemaShield is designed to
 - Immutable mode for data protection.
 - Lightweight and fast.
 - Easy to use and extend.
+- No dependencies.
 - Typescript support.
 
 ## Usage
@@ -124,9 +127,9 @@ if (validationResult.valid) {
 
 **`validationResult`**: Contains the following properties:
 
-- `data`: The validated (and potentially modified) data
-- `error`: A `ValidationError` instance if validation failed, otherwise null
-- `valid`: true if validation was successful, otherwise false
+- `data`: The validated (and potentially modified) data.
+- `error`: A `ValidationError` instance if validation failed, otherwise null.
+- `valid`: true if validation was successful, otherwise false.
 
 ## No Code Generation
 
@@ -147,30 +150,14 @@ You can see a full example of this in the [No Code Generation opened possibiliti
 
 ## Error Handling
 
-SchemaShield provides a `ValidationError` class to handle errors that occur during schema validation. When a validation error is encountered, a `ValidationError` instance is returned in the error property of the validation result.
-
-This returned error instance uses the new [Error: cause](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) property introduced in ES6. This allows you to analyze the whole error chain or to retrieve the root cause of the error using the `getCause()` method.
-
-### ValidationError Properties
-
-- `message`: A string containing a description of the error
-- `item`: The final item in the path that caused the error
-- `keyword`: The keyword that triggered the error
-- `cause`: A nested ValidationError that caused the current error
-- `path`: The JSON Pointer path to the error location in the schema (Only available using the `getCause()` method)
-- `data`: The data that caused the error (optional)
-- `schema`: The compiled schema that caused the error (optional)
-
-### Get the cause of the error
-
-You can use the `getCause()` method to retrieve the root cause of a validation error. This method returns the nested ValidationError instance that triggered the current error and contains the `path` property.
+SchemaShield provides comprehensive error handling for schema validation. When a validation error occurs, a `ValidationError` instance is returned in the error property of the validation result. This error has the `getPath()` method, which is particularly useful for quickly identifying the location of an error in both the schema and the data.
 
 **Example:**
 
 ```javascript
 import { SchemaShield } from "schema-shield";
 
-const schemaShield = new SchemaShield({ immutable: true });
+const schemaShield = new SchemaShield();
 
 const schema = {
   type: "object",
@@ -197,16 +184,15 @@ if (validationResult.valid) {
 } else {
   console.error("Validation error:", validationResult.error.message); // "Property is invalid"
 
-  // Get the root cause of the error
-  const errorCause = validationResult.error.getCause();
-  console.error("Root cause:", errorCause.message); // "Value is less than the minimum"
-  console.error("Error path:", errorCause.path); // "#/properties/age/minimum"
-  console.error("Error data:", errorCause.data); // 15
-  console.error("Error schema:", errorCause.schema); // 18
-  console.error("Error keyword:", errorCause.keyword); // "minimum"
+  // Get the paths to the error location in the schema and in the data
+  const errorPaths = validationResult.error.getPath();
+  console.error("Schema path:", errorPaths.schemaPath); // "#/properties/age/minimum"
+  console.error("Instance path:", errorPaths.instancePath); // "#/age"
 }
 ```
 
+For more advanced error handling and a detailed explanation of the ValidationError properties and methods, refer to the [More on Error Handling](#more-on-error-handling) section.
+
 ## Adding Custom Types
 
 SchemaShield allows you to add custom types for validation using the `addType` method.
@@ -218,11 +204,12 @@ interface TypeFunction {
   (data: any): boolean;
 }
 
-addType(name: string, validator: TypeFunction): void;
+addType(name: string, validator: TypeFunction, overwrite?: boolean): void;
 ```
 
 - `name`: The name of the custom type. This should be a unique string that does not conflict with existing types.
 - `validator`: A `TypeFunction` that takes a single argument `data` and returns a boolean value. The function should return `true` if the provided data is valid for the custom type, and `false` otherwise.
+- `overwrite` (optional): Set to `true` to overwrite an existing type with the same name. Default is `false`. If set to `false` and a type with the same name already exists, an error will be thrown.
 
 ### Example: Adding a Custom Type
 
@@ -276,11 +263,12 @@ interface FormatFunction {
   (data: any): boolean;
 }
 
-addFormat(name: string, validator: FormatFunction): void;
+addFormat(name: string, validator: FormatFunction, overwrite?: boolean): void;
 ```
 
 - `name`: The name of the custom format. This should be a unique string that does not conflict with existing formats.
 - `validator`: A FormatFunction that takes a single argument data and returns a boolean value. The function should return true if the provided data is valid for the custom format, and false otherwise.
+- `overwrite` (optional): Set to true to overwrite an existing format with the same name. Default is false. If set to false and a format with the same name already exists, an error will be thrown.
 
 ### Example: Adding a Custom Format
 
@@ -333,7 +321,7 @@ SchemaShield allows you to add custom keywords for validation using the addKeywo
 ```javascript
 type Result = void | ValidationError;
 
-export interface DefineErrorOptions {
+interface DefineErrorOptions {
   item?: any; // Final item in the path
   cause?: ValidationError; // Cause of the error
   data?: any; // Data that caused the error
@@ -352,6 +340,28 @@ interface CompiledSchema {
   [key: string]: any;
 }
 
+interface FormatFunction {
+  (data: any): boolean;
+}
+
+interface TypeFunction {
+  (data: any): boolean;
+}
+
+declare class SchemaShield {
+    constructor({ immutable }?: {
+        immutable?: boolean;
+    });
+    compile(schema: any): Validator;
+    addType(name: string, validator: TypeFunction, overwrite?: boolean): void;
+    addFormat(name: string, validator: FormatFunction, overwrite?: boolean): void;
+    addKeyword(name: string, validator: KeywordFunction, overwrite?: boolean): void;
+    getType(type: string): TypeFunction | false;
+    getFormat(format: string): FormatFunction | false;
+    getKeyword(keyword: string): KeywordFunction | false;
+    isSchemaLike(subSchema: any): boolean;
+}
+
 interface KeywordFunction {
   (
     schema: CompiledSchema,
@@ -361,11 +371,14 @@ interface KeywordFunction {
   ): Result;
 }
 
-addKeyword(name: string, validator: KeywordFunction): void;
+
+
+addKeyword(name: string, validator: KeywordFunction, overwrite?: boolean): void;
 ```
 
 - `name`: The name of the custom keyword. This should be a unique string that does not conflict with existing keywords.
 - `validator`: A `KeywordFunction` that takes four arguments: `schema`, `data`, `defineError`, and `instance` (The SchemaShield instance that is currently running the validation). The function should not return anything if the data is valid for the custom keyword, and should return a `ValidationError` instance if the data is invalid.
+- `overwrite` (optional): Set to true to overwrite an existing keyword with the same name. Default is false. If set to false and a keyword with the same name already exists, an error will be thrown.
 
 #### About the `defineError` Function
 
@@ -388,7 +401,7 @@ In this example, we'll add a custom keyword called divisibleBy that validates if
 ```javascript
 import { SchemaShield, ValidationError } from "./path/to/SchemaShield";
 
-const schemaShield = new SchemaShield({ immutable: true });
+const schemaShield = new SchemaShield();
 
 // Custom keyword 'divisibleBy' validator function
 const divisibleByValidator = (schema, data, defineError, instance) => {
@@ -465,9 +478,9 @@ const prefixedUsername = (schema, data, defineError, instance) => {
 
   // Get the validators for the specified types and formats from the instance
   // (if they exist)
-  const typeValidator = instance.types.get(validType);
-  const prefixValidator = instance.keywords.get(prefixValidator);
-  const formatValidator = instance.formats.get(validFormat);
+  const typeValidator = instance.getType(validType);
+  const prefixValidator = instance.getKeyword(prefixValidator);
+  const formatValidator = instance.getFormat(validFormat);
 
   for (let i = 0; i < data.length; i++) {
     const item = data[i];
@@ -572,9 +585,9 @@ schemaShield.addKeyword(
   (schema, data, defineError, instance) => {
     const { assignment, project, employee } = data;
 
-    const stringTypeValidator = instance.types.get("string");
-    const projectTypeValidator = instance.types.get("project");
-    const employeeTypeValidator = instance.types.get("employee");
+    const stringTypeValidator = instance.getType("string");
+    const projectTypeValidator = instance.getType("project");
+    const employeeTypeValidator = instance.getType("employee");
 
     if (!stringTypeValidator(assignment)) {
       return defineError("Assignment must be a string", {
@@ -651,6 +664,255 @@ if (validationResult.valid) {
 
 In this example, SchemaShield safely accesses instances of custom classes and utilizes them in the validation process. This level of complexity and flexibility would not be possible or would require a lot of boilerplate code with other libraries that rely on code generation.
 
+## More on Error Handling
+
+SchemaShield provides a `ValidationError` class to handle errors that occur during schema validation. When a validation error is encountered, a `ValidationError` instance is returned in the error property of the validation result.
+
+This error instance uses the new [Error: cause](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) property introduced in ES6. This allows you to analyze the whole error chain or to retrieve the root cause of the error using the `getCause()` `getTree()` and `getPath()` methods.
+
+### ValidationError Properties
+
+- `message`: A string containing a description of the error.
+- `item`: The final item in the path that caused the error (either a string or a number) (optional).
+- `keyword`: The keyword that triggered the error.
+- `cause`: A nested ValidationError or a normal Error that caused the current error.
+- `schemaPath`: The JSON Pointer path to the error location in the schema.
+- `instancePath`: The JSON Pointer path to the error location in the data.
+- `data`: The data that caused the error (optional).
+- `schema`: The schema that caused the error (optional).
+
+_Note:_ The `schemaPath` and `instancePath` will be only available after using the `getCause()` `getTree()` or `getPath()` methods.
+
+### Get the path to the error location
+
+You can use the `getPath` method to get the JSON Pointer path to the error location in the schema and in the data. This method returns an object containing the `schemaPath` and `instancePath`.
+
+**Example:**
+
+```javascript
+import { SchemaShield } from "schema-shield";
+
+const schemaShield = new SchemaShield();
+
+const schema = {
+  type: "object",
+  properties: {
+    description: { type: "string" },
+    shouldLoadDb: { type: "boolean" },
+    enableNetConnectFor: { type: "array", items: { type: "string" } },
+    params: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        properties: {
+          description: { type: "string" },
+          default: { type: "string" }
+        },
+        required: ["description"]
+      }
+    },
+    run: { type: "string" }
+  }
+};
+
+const validator = schemaShield.compile(schema);
+
+const invalidData = {
+  description: "Say hello to the bot.",
+  shouldLoadDb: false,
+  enableNetConnectFor: [],
+  params: {
+    color: {
+      type: "string",
+      // description: "The color of the text", // Missing description on purpose
+      default: "red"
+    }
+  },
+  run: "run"
+};
+
+const validationResult = validator(invalidData);
+
+if (validationResult.valid) {
+  console.log("Data is valid:", validationResult.data);
+} else {
+  console.error("Validation error:", validationResult.error.message); // "Property is invalid"
+
+  // Get the paths to the error location in the schema and in the data
+  const errorPaths = validationResult.error.getPath();
+  console.error("Schema path:", errorPaths.schemaPath); // "#/properties/params/additionalProperties/required"
+  console.error("Instance path:", errorPaths.instancePath); // "#/params/color/description"
+}
+```
+
+### Get the full error chain as a tree
+
+You can use the `getTree()` method to retrieve the full error chain as a tree. This method returns an ErrorTree object with the complete nested error structure, allowing you to analyze the full chain of errors that occurred during validation.
+
+#### ErrorTree Signature
+
+```typescript
+interface ErrorTree {
+  message: string; // The error message
+  keyword: string; // The keyword that triggered the error
+  item?: string | number; // The final item in the path that caused the error (either a string or a number) (optional)
+  schemaPath: string; // The JSON Pointer path to the error location in the schema
+  instancePath: string; // The JSON Pointer path to the error location in the data
+  data?: any; // The data that caused the error (optional)
+  cause?: ErrorTree; // A nested ErrorTree representation of the nested error that caused the current error
+}
+```
+
+**Example:**
+
+```javascript
+import { SchemaShield } from "schema-shield";
+
+const schemaShield = new SchemaShield();
+
+const schema = {
+  type: "object",
+  properties: {
+    description: { type: "string" },
+    shouldLoadDb: { type: "boolean" },
+    enableNetConnectFor: { type: "array", items: { type: "string" } },
+    params: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        properties: {
+          description: { type: "string" },
+          default: { type: "string" }
+        },
+        required: ["description"]
+      }
+    },
+    run: { type: "string" }
+  }
+};
+
+const validator = schemaShield.compile(schema);
+
+const invalidData = {
+  description: "Say hello to the bot.",
+  shouldLoadDb: false,
+  enableNetConnectFor: [],
+  params: {
+    color: {
+      type: "string",
+      // description: "The color of the text", // Missing description on purpose
+      default: "red"
+    }
+  },
+  run: "run"
+};
+
+const validationResult = validator(invalidData);
+
+if (validationResult.valid) {
+  console.log("Data is valid:", validationResult.data);
+} else {
+  console.error("Validation error:", validationResult.error.message); // "Property is invalid"
+
+  // Get the full error chain as a tree
+  const errorTree = validationResult.error.getTree();
+  console.error(errorTree);
+
+  /*
+    {
+      message: "Property is invalid",
+      keyword: "properties",
+      item: "params",
+      schemaPath: "#/properties/params",
+      instancePath: "#/params",
+      data: { color: { type: "string", default: "red" } },
+      cause: {
+        message: "Additional properties are invalid",
+        keyword: "additionalProperties",
+        item: "color",
+        schemaPath: "#/properties/params/additionalProperties",
+        instancePath: "#/params/color",
+        data: { type: "string", default: "red" },
+        cause: {
+          message: "Required property is missing",
+          keyword: "required",
+          item: "description",
+          schemaPath: "#/properties/params/additionalProperties/required",
+          instancePath: "#/params/color/description",
+          data: undefined
+        }
+      }
+    }
+  */
+}
+```
+
+The `errorTree` object contains the full error chain with nested causes, allowing you to analyze the entire error structure.
+
+### Get the cause of the error
+
+You can use the `getCause()` method to retrieve the root cause of a validation error. This method returns the nested ValidationError instance that triggered the current error and contains the `schemaPath` and `instancePath` properties.
+
+```javascript
+import { SchemaShield } from "schema-shield";
+
+const schemaShield = new SchemaShield();
+
+const schema = {
+  type: "object",
+  properties: {
+    description: { type: "string" },
+    shouldLoadDb: { type: "boolean" },
+    enableNetConnectFor: { type: "array", items: { type: "string" } },
+    params: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        properties: {
+          description: { type: "string" },
+          default: { type: "string" }
+        },
+        required: ["description"]
+      }
+    },
+    run: { type: "string" }
+  }
+};
+
+const validator = schemaShield.compile(schema);
+
+const invalidData = {
+  description: "Say hello to the bot.",
+  shouldLoadDb: false,
+  enableNetConnectFor: [],
+  params: {
+    color: {
+      type: "string",
+      // description: "The color of the text", // Missing description on purpose
+      default: "red"
+    }
+  },
+  run: "run"
+};
+
+const validationResult = validator(invalidData);
+
+if (validationResult.valid) {
+  console.log("Data is valid:", validationResult.data);
+} else {
+  console.error("Validation error:", validationResult.error.message); // "Property is invalid"
+
+  // Get the root cause of the error
+  const errorCause = validationResult.error.getCause();
+  console.error("Root cause:", errorCause.message); // "Required property is missing"
+  console.error("Schema path:", errorCause.schemaPath); // "#/properties/params/additionalProperties/required"
+  console.error("Instance path:", errorCause.instancePath); // "#/params/color/description"
+  console.error("Error data:", errorCause.data); // undefined
+  console.error("Error schema:", errorCause.schema); // ["description"]
+  console.error("Error keyword:", errorCause.keyword); // "required"
+}
+```
+
 ## Immutable Mode
 
 SchemaShield offers an optional immutable mode to prevent modifications to the input data during validation. In some cases, SchemaShield may mutate the data when using the `default` keyword or within custom added keywords.
@@ -685,14 +947,7 @@ For now, consider using custom implementations using the `addKeyword` method or
 
 ### Unsupported Formats
 
-SchemaShield currently does not support the following formats, but they are planned to be addressed in future updates of SchemaShield. For now, consider using custom implementations using the `addFormat` method to handle these formats.
-
-- `duration`
-- `uuid`
-- `uri-reference`
-- `uri-template`
-
-### Internationalized Formats
+#### Internationalized Formats
 
 There is no plan to support the following formats in SchemaShield, as they are not relevant to the majority of use cases. If you need to use these formats, consider using custom implementations using the `addFormat` method to handle them.
 

package/dist/formats.d.ts

@@ -1,3 +1,3 @@
-import { FormatFunction } from './index';
+import { FormatFunction } from "./index";
 export declare const Formats: Record<string, FormatFunction | false>;
 //# sourceMappingURL=formats.d.ts.map

package/dist/formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../lib/formats.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAgBzC,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,KAAK,CAkF1D,CAAC"}
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../lib/formats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,KAAK,CA+O1D,CAAC"}

package/dist/index.d.ts

@@ -25,16 +25,19 @@ export interface Validator {
     compiledSchema: CompiledSchema;
 }
 export declare class SchemaShield {
-    types: Map<string, false | TypeFunction>;
-    formats: Map<string, false | FormatFunction>;
-    keywords: Map<string, false | KeywordFunction>;
-    immutable: boolean;
+    private types;
+    private formats;
+    private keywords;
+    private immutable;
     constructor({ immutable }?: {
         immutable?: boolean;
     });
-    addType(name: string, validator: TypeFunction): void;
-    addFormat(name: string, validator: FormatFunction): void;
-    addKeyword(name: string, validator: KeywordFunction): void;
+    addType(name: string, validator: TypeFunction, overwrite?: boolean): void;
+    getType(type: string): TypeFunction | false;
+    addFormat(name: string, validator: FormatFunction, overwrite?: boolean): void;
+    getFormat(format: string): FormatFunction | false;
+    addKeyword(name: string, validator: KeywordFunction, overwrite?: boolean): void;
+    getKeyword(keyword: string): KeywordFunction | false;
     compile(schema: any): Validator;
     private compileSchema;
     isSchemaLike(subSchema: any): boolean;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAKhB,MAAM,SAAS,CAAC;AAMjB,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,eAAe,CAAC;AAE5C,MAAM,WAAW,eAAe;IAC9B,CACE,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,GAAG,EACT,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,YAAY,GACrB,MAAM,CAAC;CACX;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB,CAAC,IAAI,EAAE,GAAG,GAAG;QAAE,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1E,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,qBAAa,YAAY;IACvB,KAAK,oCAA2C;IAChD,OAAO,sCAA6C;IACpD,QAAQ,uCAA8C;IACtD,SAAS,UAAS;gBAEN,EACV,SAAiB,EAClB,GAAE;QACD,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB;IAoBN,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY;IAI7C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc;IAIjD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe;IAInD,OAAO,CAAC,MAAM,EAAE,GAAG,GAAG,SAAS;IA6B/B,OAAO,CAAC,aAAa;IAkIrB,YAAY,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO;CActC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAKhB,MAAM,SAAS,CAAC;AAMjB,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,eAAe,CAAC;AAE5C,MAAM,WAAW,eAAe;IAC9B,CACE,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,GAAG,EACT,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,YAAY,GACrB,MAAM,CAAC;CACX;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB,CAAC,IAAI,EAAE,GAAG,GAAG;QAAE,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1E,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,OAAO,CAA8C;IAC7D,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,SAAS,CAAS;gBAEd,EACV,SAAiB,EAClB,GAAE;QACD,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB;IAoBN,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,UAAQ;IAOhE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,KAAK;IAI3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,UAAQ;IAOpE,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,KAAK;IAIjD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,SAAS,UAAQ;IAOtE,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,KAAK;IAIpD,OAAO,CAAC,MAAM,EAAE,GAAG,GAAG,SAAS;IA6B/B,OAAO,CAAC,aAAa;IA0IrB,YAAY,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO;CActC"}