@dicebear/core 10.0.0-rc.2 → 10.0.0-rc.4

package/lib/Validator/OptionsValidator.js

@@ -2,2167 +2,2041 @@ import { OptionsValidationError } from '../Error/OptionsValidationError.js';
 function ucs2length(str) { let n = 0; for (const _ of str)
     n++; return n; }
 "use strict";
-const schema11 = { "$id": "https://cdn.hopjs.net/npm/@dicebear/schema@0.10.0/dist/options.min.json", "$schema": "http://json-schema.org/draft-07/schema#", "title": "DiceBear options schema", "type": "object", "definitions": { "flip": { "type": "string", "enum": ["none", "horizontal", "vertical", "both"] }, "rotate": { "type": "number", "minimum": -360, "maximum": 360 }, "scale": { "type": "number", "minimum": 0 }, "translate": { "type": "number", "minimum": -100, "maximum": 100 }, "borderRadius": { "type": "number", "minimum": 0, "maximum": 50 }, "color": { "type": "string", "pattern": "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, "colorFill": { "type": "string", "enum": ["solid", "linear", "radial"] }, "colorFillStops": { "type": "integer", "minimum": 2 }, "fontFamilyName": { "type": "string", "pattern": "^[a-zA-Z0-9 _\\-]+$" }, "fontWeight": { "type": "integer", "minimum": 1, "maximum": 1000 } }, "properties": { "seed": { "type": "string", "description": "The starting value for the pseudorandom number generator (PRNG) used in the avatar generation process. This option is essential for creating unique and consistent avatars. By setting a specific seed, you ensure that the same sequence of random characteristics is applied, allowing identical avatars to be reproduced. This is especially valuable for maintaining consistency across sessions and allowing users to share or recreate their personalized avatars.", "maxLength": 1024 }, "size": { "type": "integer", "description": "Specifies the dimensions of the avatar in pixels. If no size is specified, the avatar defaults to a responsive design or scales to 100% of its container. This flexibility allows the avatar to seamlessly adapt to different screen sizes and layouts, ensuring optimal display across devices and environments.", "minimum": 1 }, "idRandomization": { "type": "boolean", "description": "Generates random values for all IDs present in the SVG. This process ensures that while the avatar appears visually identical, the underlying code remains unique. This is particularly useful for embedding the same avatar multiple times in a document without running into duplicate ID conflicts that can interfere with styles and scripts." }, "title": { "type": "string", "description": "Specifies an accessible title for the avatar. When set, the SVG will include a <title> element and an aria-label attribute, allowing screen readers and other assistive technologies to describe the avatar to users.", "maxLength": 256 }, "flip": { "description": "Specifies how the avatar will be flipped. Options include `none` for no flip, `horizontal` for a left-to-right flip, `vertical` for an upside-down flip, and `both` for a complete flip. If specified as an array, the PRNG will choose from the available options.", "oneOf": [{ "$ref": "#/definitions/flip" }, { "type": "array", "items": { "$ref": "#/definitions/flip" }, "maxItems": 128 }] }, "fontFamily": { "description": "Specifies the font family used for text rendering. If specified as an array, the PRNG will choose from the available options.", "oneOf": [{ "$ref": "#/definitions/fontFamilyName" }, { "type": "array", "items": { "$ref": "#/definitions/fontFamilyName" }, "maxItems": 128 }] }, "fontWeight": { "description": "Specifies the font weight used for text rendering. The value must be an integer between 1 and 1000. If specified as an array, the PRNG will choose from the available options.", "oneOf": [{ "$ref": "#/definitions/fontWeight" }, { "type": "array", "items": { "$ref": "#/definitions/fontWeight" }, "maxItems": 128 }] }, "scale": { "description": "Sets the scaling of the avatar. A value of `1` corresponds to the original size of the avatar. This setting affects the size of the avatar itself, but not the size of the avatar container; any excess content will be clipped. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "oneOf": [{ "$ref": "#/definitions/scale" }, { "type": "array", "items": { "$ref": "#/definitions/scale" }, "maxItems": 2 }] }, "borderRadius": { "description": "This is the radius of the corners of the avatar. This value can be a float or an integer. A value of 0 means that the avatar has sharp corners, while larger values result in more rounded corners. The maximum value is 50, which turns the avatar into a complete circle. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "oneOf": [{ "$ref": "#/definitions/borderRadius" }, { "type": "array", "items": { "$ref": "#/definitions/borderRadius" }, "maxItems": 2 }] } }, "patternProperties": { "^[a-z][a-zA-Z0-9]*Probability$": { "type": "number", "description": "Represents the probability that a component of the avatar will be displayed. The value can be either a float or an integer, but is interpreted as a percentage. For example, a value of 0 means the part will never be displayed, while a value of 100 means it will always be displayed.", "minimum": 0, "maximum": 100 }, "^[a-z][a-zA-Z0-9]*Variant$": { "description": "Specifies which variants of the avatar part can be selected by the PRNG and their relative weights. A string or array of strings filters which variants the PRNG can choose from. An object maps variant names to non-negative weights, simultaneously filtering and weighting selection.", "oneOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" }, "maxItems": 128 }, { "type": "object", "propertyNames": { "pattern": "^[a-z][a-zA-Z0-9]*$" }, "additionalProperties": { "type": "number", "minimum": 0 }, "maxProperties": 128 }] }, "^[a-z][a-zA-Z0-9]*Color$": { "description": "Specifies which colors for the avatar component can be selected by the PRNG. If specified as a string or array with only one value, the value is fixed. However, if specified as an array with multiple values, the PRNG will choose from the available options. The color must be specified as a hex value.", "oneOf": [{ "$ref": "#/definitions/color" }, { "type": "array", "items": { "$ref": "#/definitions/color" }, "maxItems": 128 }] }, "^[a-z][a-zA-Z0-9]*ColorFill$": { "description": "Specifies the color fill method for the avatar component. Options include `solid` for a flat color, `linear` for a linear gradient, and `radial` for a radial gradient. If specified as a string or array with only one value, the value is fixed. However, if specified as an array with multiple values, the PRNG will choose from the available options.", "oneOf": [{ "$ref": "#/definitions/colorFill" }, { "type": "array", "items": { "$ref": "#/definitions/colorFill" }, "maxItems": 128 }] }, "^[a-z][a-zA-Z0-9]*ColorFillStops$": { "description": "Specifies the number of color stops for gradient fills. This value is only relevant when the color fill method is set to `linear` or `radial`. The minimum value is 1. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "oneOf": [{ "$ref": "#/definitions/colorFillStops" }, { "type": "array", "items": { "$ref": "#/definitions/colorFillStops" }, "maxItems": 2 }] }, "^[a-z][a-zA-Z0-9]*ColorAngle$": { "description": "Specifies the angle for the color gradient. This value can be an integer or a float. A value of 0 results in no rotation, while values between -360 and 360 define the degree of rotation. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "oneOf": [{ "$ref": "#/definitions/rotate" }, { "type": "array", "items": { "$ref": "#/definitions/rotate" }, "maxItems": 2 }] }, "^(r|[a-z][a-zA-Z0-9]*R)otate$": { "description": "This is the rotation angle for the avatar or its parts. This value can be an integer or a float. A value of 0 results in no rotation, while values between -360 and 360 define the degree of rotation in both directions. If specified as an array, the PRNG will select a value within the specified range, including the values themselves. If not preceded by an avatar part, the option applies to the entire avatar.", "oneOf": [{ "$ref": "#/definitions/rotate" }, { "type": "array", "items": { "$ref": "#/definitions/rotate" }, "maxItems": 2 }] }, "^(t|[a-z][a-zA-Z0-9]*T)ranslateY$": { "description": "This is the vertical translation of the avatar or its parts. This value can be an integer or a float. A value of 0 results in no translation, while positive values move the part down and negative values move it up. If specified as an array, the PRNG will select a value within the specified range, including the values themselves. If no avatar part is specified, the option applies to the entire avatar.", "oneOf": [{ "$ref": "#/definitions/translate" }, { "type": "array", "items": { "$ref": "#/definitions/translate" }, "maxItems": 2 }] }, "^(t|[a-z][a-zA-Z0-9]*T)ranslateX$": { "description": "This is the horizontal translation of the avatar or its parts. This value can be an integer or a float. A value of 0 results in no translation, while positive values move the part to the right and negative values move it to the left. If specified as an array, the PRNG will select a value within the specified range, including the values themselves. If no avatar part is specified, the option applies to the entire avatar.", "oneOf": [{ "$ref": "#/definitions/translate" }, { "type": "array", "items": { "$ref": "#/definitions/translate" }, "maxItems": 2 }] } }, "additionalProperties": false };
+const schema11 = { "$id": "https://cdn.hopjs.net/npm/@dicebear/schema@0.14.1/dist/options.min.json", "$schema": "http://json-schema.org/draft-07/schema#", "title": "DiceBear options schema", "type": "object", "definitions": { "flip": { "type": "string", "enum": ["none", "horizontal", "vertical", "both"] }, "rotate": { "type": "number", "minimum": -360, "maximum": 360 }, "scale": { "type": "number", "minimum": 0, "maximum": 10 }, "translate": { "type": "number", "minimum": -1000, "maximum": 1000 }, "borderRadius": { "type": "number", "minimum": 0, "maximum": 50 }, "color": { "type": "string", "pattern": "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, "colorFill": { "type": "string", "enum": ["solid", "linear", "radial"] }, "colorFillStops": { "type": "integer", "minimum": 2 }, "fontFamilyName": { "type": "string", "pattern": "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$", "maxLength": 256 }, "fontWeight": { "type": "integer", "minimum": 1, "maximum": 1000 }, "variantName": { "type": "string", "pattern": "^[a-z][a-zA-Z0-9]*$", "maxLength": 64 }, "rotateOption": { "anyOf": [{ "$ref": "#/definitions/rotate" }, { "type": "array", "items": { "$ref": "#/definitions/rotate" }, "minItems": 0, "maxItems": 2 }] }, "translateOption": { "anyOf": [{ "$ref": "#/definitions/translate" }, { "type": "array", "items": { "$ref": "#/definitions/translate" }, "minItems": 0, "maxItems": 2 }] }, "scaleOption": { "anyOf": [{ "$ref": "#/definitions/scale" }, { "type": "array", "items": { "$ref": "#/definitions/scale" }, "minItems": 0, "maxItems": 2 }] } }, "properties": { "seed": { "type": "string", "description": "The starting value for the pseudorandom number generator (PRNG) used in the avatar generation process. This option is essential for creating unique and consistent avatars. By setting a specific seed, you ensure that the same sequence of random characteristics is applied, allowing identical avatars to be reproduced. This is especially valuable for maintaining consistency across sessions and allowing users to share or recreate their personalized avatars.", "maxLength": 1024 }, "size": { "type": "integer", "description": "Specifies the dimensions of the avatar in pixels. If no size is specified, the avatar defaults to a responsive design or scales to 100% of its container. This flexibility allows the avatar to seamlessly adapt to different screen sizes and layouts, ensuring optimal display across devices and environments.", "minimum": 1, "maximum": 4096 }, "idRandomization": { "type": "boolean", "description": "Generates random values for all IDs present in the SVG. This process ensures that while the avatar appears visually identical, the underlying code remains unique. This is particularly useful for embedding the same avatar multiple times in a document without running into duplicate ID conflicts that can interfere with styles and scripts." }, "title": { "type": "string", "description": "Specifies an accessible title for the avatar. When set, the SVG will include a <title> element and an aria-label attribute, allowing screen readers and other assistive technologies to describe the avatar to users.", "maxLength": 256 }, "flip": { "description": "Specifies how the avatar will be flipped. Options include `none` for no flip, `horizontal` for a left-to-right flip, `vertical` for an upside-down flip, and `both` for a complete flip. If specified as an array, the PRNG will choose from the available options.", "anyOf": [{ "$ref": "#/definitions/flip" }, { "type": "array", "items": { "$ref": "#/definitions/flip" }, "minItems": 0, "maxItems": 128 }] }, "fontFamily": { "description": "Specifies the font family used for text rendering. If specified as an array, the PRNG will choose from the available options.", "anyOf": [{ "$ref": "#/definitions/fontFamilyName" }, { "type": "array", "items": { "$ref": "#/definitions/fontFamilyName" }, "minItems": 0, "maxItems": 128 }] }, "fontWeight": { "description": "Specifies the font weight used for text rendering. The value must be an integer between 1 and 1000. If specified as an array, the PRNG will choose from the available options.", "anyOf": [{ "$ref": "#/definitions/fontWeight" }, { "type": "array", "items": { "$ref": "#/definitions/fontWeight" }, "minItems": 0, "maxItems": 128 }] }, "scale": { "description": "Sets the scaling of the avatar. A value of `1` corresponds to the original size of the avatar. This setting affects the size of the avatar itself, but not the size of the avatar container; any excess content will be clipped. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "allOf": [{ "$ref": "#/definitions/scaleOption" }] }, "borderRadius": { "description": "This is the radius of the corners of the avatar. This value can be a float or an integer. A value of 0 means that the avatar has sharp corners, while larger values result in more rounded corners. The maximum value is 50, which turns the avatar into a complete circle. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "anyOf": [{ "$ref": "#/definitions/borderRadius" }, { "type": "array", "items": { "$ref": "#/definitions/borderRadius" }, "minItems": 0, "maxItems": 2 }] } }, "patternProperties": { "^[a-z][a-zA-Z0-9]*Probability$": { "type": "number", "description": "Represents the probability that a component of the avatar will be displayed. The value can be either a float or an integer, but is interpreted as a percentage. For example, a value of 0 means the part will never be displayed, while a value of 100 means it will always be displayed.", "minimum": 0, "maximum": 100 }, "^[a-z][a-zA-Z0-9]*Variant$": { "description": "Specifies which variants of the avatar part can be selected by the PRNG and their relative weights. A string or array of strings filters which variants the PRNG can choose from. An object maps variant names to non-negative weights, simultaneously filtering and weighting selection. Variant names must be camelCase identifiers.", "anyOf": [{ "$ref": "#/definitions/variantName" }, { "type": "array", "items": { "$ref": "#/definitions/variantName" }, "minItems": 0, "maxItems": 128 }, { "type": "object", "propertyNames": { "$ref": "#/definitions/variantName" }, "additionalProperties": { "type": "number", "minimum": 0 }, "minProperties": 1, "maxProperties": 512 }] }, "^[a-z][a-zA-Z0-9]*Color$": { "description": "Specifies which colors for the avatar component can be selected by the PRNG. If specified as a string or array with only one value, the value is fixed. However, if specified as an array with multiple values, the PRNG will choose from the available options. The color must be specified as a hex value.", "anyOf": [{ "$ref": "#/definitions/color" }, { "type": "array", "items": { "$ref": "#/definitions/color" }, "minItems": 0, "maxItems": 128 }] }, "^[a-z][a-zA-Z0-9]*ColorFill$": { "description": "Specifies the color fill method for the avatar component. Options include `solid` for a flat color, `linear` for a linear gradient, and `radial` for a radial gradient. If specified as a string or array with only one value, the value is fixed. However, if specified as an array with multiple values, the PRNG will choose from the available options.", "anyOf": [{ "$ref": "#/definitions/colorFill" }, { "type": "array", "items": { "$ref": "#/definitions/colorFill" }, "minItems": 0, "maxItems": 128 }] }, "^[a-z][a-zA-Z0-9]*ColorFillStops$": { "description": "Specifies the number of color stops for gradient fills. This value is only relevant when the color fill method is set to `linear` or `radial`. The minimum value is 2. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "anyOf": [{ "$ref": "#/definitions/colorFillStops" }, { "type": "array", "items": { "$ref": "#/definitions/colorFillStops" }, "minItems": 0, "maxItems": 2 }] }, "^[a-z][a-zA-Z0-9]*ColorAngle$": { "description": "Specifies the angle for the color gradient. This value can be an integer or a float. A value of 0 results in no rotation, while values between -360 and 360 define the degree of rotation. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "allOf": [{ "$ref": "#/definitions/rotateOption" }] }, "^rotate$": { "description": "This is the rotation angle for the entire avatar. This value can be an integer or a float. A value of 0 results in no rotation, while values between -360 and 360 define the degree of rotation in both directions. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "allOf": [{ "$ref": "#/definitions/rotateOption" }] }, "^translateY$": { "description": "This is the vertical translation of the entire avatar. This value can be an integer or a float. A value of 0 results in no translation, while positive values move the avatar down and negative values move it up. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "allOf": [{ "$ref": "#/definitions/translateOption" }] }, "^translateX$": { "description": "This is the horizontal translation of the entire avatar. This value can be an integer or a float. A value of 0 results in no translation, while positive values move the avatar to the right and negative values move it to the left. If specified as an array, the PRNG will select a value within the specified range, including the values themselves.", "allOf": [{ "$ref": "#/definitions/translateOption" }] } }, "propertyNames": { "maxLength": 128 }, "additionalProperties": false, "maxProperties": 512 };
 const schema12 = { "type": "string", "enum": ["none", "horizontal", "vertical", "both"] };
-const schema14 = { "type": "string", "pattern": "^[a-zA-Z0-9 _\\-]+$" };
+const schema14 = { "type": "string", "pattern": "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$", "maxLength": 256 };
 const schema16 = { "type": "integer", "minimum": 1, "maximum": 1000 };
-const schema18 = { "type": "number", "minimum": 0 };
-const schema20 = { "type": "number", "minimum": 0, "maximum": 50 };
-const schema22 = { "type": "string", "pattern": "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" };
-const schema24 = { "type": "string", "enum": ["solid", "linear", "radial"] };
-const schema26 = { "type": "integer", "minimum": 2 };
-const schema28 = { "type": "number", "minimum": -360, "maximum": 360 };
-const schema32 = { "type": "number", "minimum": -100, "maximum": 100 };
-const func2 = Object.prototype.hasOwnProperty;
-const func3 = ucs2length;
+const schema21 = { "type": "number", "minimum": 0, "maximum": 50 };
+const schema23 = { "type": "string", "pattern": "^[a-z][a-zA-Z0-9]*$", "maxLength": 64 };
+const schema26 = { "type": "string", "pattern": "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" };
+const schema28 = { "type": "string", "enum": ["solid", "linear", "radial"] };
+const schema30 = { "type": "integer", "minimum": 2 };
+const func2 = ucs2length;
+const func3 = Object.prototype.hasOwnProperty;
 const pattern0 = new RegExp("^[a-z][a-zA-Z0-9]*Probability$", "u");
 const pattern1 = new RegExp("^[a-z][a-zA-Z0-9]*Variant$", "u");
 const pattern2 = new RegExp("^[a-z][a-zA-Z0-9]*Color$", "u");
 const pattern3 = new RegExp("^[a-z][a-zA-Z0-9]*ColorFill$", "u");
 const pattern4 = new RegExp("^[a-z][a-zA-Z0-9]*ColorFillStops$", "u");
 const pattern5 = new RegExp("^[a-z][a-zA-Z0-9]*ColorAngle$", "u");
-const pattern6 = new RegExp("^(r|[a-z][a-zA-Z0-9]*R)otate$", "u");
-const pattern7 = new RegExp("^(t|[a-z][a-zA-Z0-9]*T)ranslateY$", "u");
-const pattern8 = new RegExp("^(t|[a-z][a-zA-Z0-9]*T)ranslateX$", "u");
-const pattern9 = new RegExp("^[a-zA-Z0-9 _\\-]+$", "u");
+const pattern6 = new RegExp("^rotate$", "u");
+const pattern7 = new RegExp("^translateY$", "u");
+const pattern8 = new RegExp("^translateX$", "u");
+const pattern9 = new RegExp("^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$", "u");
 const pattern13 = new RegExp("^[a-z][a-zA-Z0-9]*$", "u");
-const pattern15 = new RegExp("^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$", "u");
-function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { /*# sourceURL="https://cdn.hopjs.net/npm/@dicebear/schema@0.10.0/dist/options.min.json" */ ; let vErrors = null; let errors = 0; if (errors === 0) {
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-        const _errs1 = errors;
-        for (const key0 in data) {
-            if (!((((((((((func2.call(schema11.properties, key0)) || (pattern0.test(key0))) || (pattern1.test(key0))) || (pattern2.test(key0))) || (pattern3.test(key0))) || (pattern4.test(key0))) || (pattern5.test(key0))) || (pattern6.test(key0))) || (pattern7.test(key0))) || (pattern8.test(key0)))) {
-                validate10.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
-                return false;
-                break;
+const pattern17 = new RegExp("^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$", "u");
+const schema18 = { "anyOf": [{ "$ref": "#/definitions/scale" }, { "type": "array", "items": { "$ref": "#/definitions/scale" }, "minItems": 0, "maxItems": 2 }] };
+const schema19 = { "type": "number", "minimum": 0, "maximum": 10 };
+function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; const _errs0 = errors; let valid0 = false; const _errs1 = errors; const _errs2 = errors; if (errors === _errs2) {
+    if ((typeof data == "number") && (isFinite(data))) {
+        if (data > 10 || isNaN(data)) {
+            const err0 = { instancePath, schemaPath: "#/definitions/scale/maximum", keyword: "maximum", params: { comparison: "<=", limit: 10 }, message: "must be <= 10" };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
             }
+            errors++;
         }
-        if (_errs1 === errors) {
-            if (data.seed !== undefined) {
-                let data0 = data.seed;
-                const _errs2 = errors;
-                if (errors === _errs2) {
-                    if (typeof data0 === "string") {
-                        if (func3(data0) > 1024) {
-                            validate10.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
-                            return false;
-                        }
-                    }
-                    else {
-                        validate10.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                        return false;
-                    }
+        else {
+            if (data < 0 || isNaN(data)) {
+                const err1 = { instancePath, schemaPath: "#/definitions/scale/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                if (vErrors === null) {
+                    vErrors = [err1];
                 }
-                var valid0 = _errs2 === errors;
-            }
-            else {
-                var valid0 = true;
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
             }
-            if (valid0) {
-                if (data.size !== undefined) {
-                    let data1 = data.size;
-                    const _errs4 = errors;
-                    if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
-                        validate10.errors = [{ instancePath: instancePath + "/size", schemaPath: "#/properties/size/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
-                        return false;
-                    }
-                    if (errors === _errs4) {
-                        if ((typeof data1 == "number") && (isFinite(data1))) {
-                            if (data1 < 1 || isNaN(data1)) {
-                                validate10.errors = [{ instancePath: instancePath + "/size", schemaPath: "#/properties/size/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
-                                return false;
-                            }
-                        }
-                    }
-                    var valid0 = _errs4 === errors;
+        }
+    }
+    else {
+        const err2 = { instancePath, schemaPath: "#/definitions/scale/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+} var _valid0 = _errs1 === errors; valid0 = valid0 || _valid0; if (!valid0) {
+    const _errs4 = errors;
+    if (errors === _errs4) {
+        if (Array.isArray(data)) {
+            if (data.length > 2) {
+                const err3 = { instancePath, schemaPath: "#/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                if (vErrors === null) {
+                    vErrors = [err3];
                 }
                 else {
-                    var valid0 = true;
+                    vErrors.push(err3);
                 }
-                if (valid0) {
-                    if (data.idRandomization !== undefined) {
-                        const _errs6 = errors;
-                        if (typeof data.idRandomization !== "boolean") {
-                            validate10.errors = [{ instancePath: instancePath + "/idRandomization", schemaPath: "#/properties/idRandomization/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
-                            return false;
-                        }
-                        var valid0 = _errs6 === errors;
+                errors++;
+            }
+            else {
+                if (data.length < 0) {
+                    const err4 = { instancePath, schemaPath: "#/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
                     }
                     else {
-                        var valid0 = true;
+                        vErrors.push(err4);
                     }
-                    if (valid0) {
-                        if (data.title !== undefined) {
-                            let data3 = data.title;
-                            const _errs8 = errors;
-                            if (errors === _errs8) {
-                                if (typeof data3 === "string") {
-                                    if (func3(data3) > 256) {
-                                        validate10.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
-                                        return false;
+                    errors++;
+                }
+                else {
+                    var valid2 = true;
+                    const len0 = data.length;
+                    for (let i0 = 0; i0 < len0; i0++) {
+                        let data0 = data[i0];
+                        const _errs6 = errors;
+                        const _errs7 = errors;
+                        if (errors === _errs7) {
+                            if ((typeof data0 == "number") && (isFinite(data0))) {
+                                if (data0 > 10 || isNaN(data0)) {
+                                    const err5 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/scale/maximum", keyword: "maximum", params: { comparison: "<=", limit: 10 }, message: "must be <= 10" };
+                                    if (vErrors === null) {
+                                        vErrors = [err5];
+                                    }
+                                    else {
+                                        vErrors.push(err5);
                                     }
+                                    errors++;
                                 }
                                 else {
-                                    validate10.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                    return false;
+                                    if (data0 < 0 || isNaN(data0)) {
+                                        const err6 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/scale/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                        if (vErrors === null) {
+                                            vErrors = [err6];
+                                        }
+                                        else {
+                                            vErrors.push(err6);
+                                        }
+                                        errors++;
+                                    }
+                                }
+                            }
+                            else {
+                                const err7 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/scale/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                if (vErrors === null) {
+                                    vErrors = [err7];
+                                }
+                                else {
+                                    vErrors.push(err7);
                                 }
+                                errors++;
                             }
-                            var valid0 = _errs8 === errors;
                         }
-                        else {
-                            var valid0 = true;
+                        var valid2 = _errs6 === errors;
+                        if (!valid2) {
+                            break;
                         }
-                        if (valid0) {
-                            if (data.flip !== undefined) {
-                                let data4 = data.flip;
-                                const _errs10 = errors;
-                                const _errs11 = errors;
-                                let valid1 = false;
-                                let passing0 = null;
-                                const _errs12 = errors;
-                                if (typeof data4 !== "string") {
-                                    const err0 = { instancePath: instancePath + "/flip", schemaPath: "#/definitions/flip/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                    if (vErrors === null) {
-                                        vErrors = [err0];
-                                    }
-                                    else {
-                                        vErrors.push(err0);
-                                    }
-                                    errors++;
-                                }
-                                if (!((((data4 === "none") || (data4 === "horizontal")) || (data4 === "vertical")) || (data4 === "both"))) {
-                                    const err1 = { instancePath: instancePath + "/flip", schemaPath: "#/definitions/flip/enum", keyword: "enum", params: { allowedValues: schema12.enum }, message: "must be equal to one of the allowed values" };
+                    }
+                }
+            }
+        }
+        else {
+            const err8 = { instancePath, schemaPath: "#/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = valid0 || _valid0;
+} if (!valid0) {
+    const err9 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+        vErrors = [err9];
+    }
+    else {
+        vErrors.push(err9);
+    }
+    errors++;
+    validate11.errors = vErrors;
+    return false;
+}
+else {
+    errors = _errs0;
+    if (vErrors !== null) {
+        if (_errs0) {
+            vErrors.length = _errs0;
+        }
+        else {
+            vErrors = null;
+        }
+    }
+} validate11.errors = vErrors; return errors === 0; }
+const schema32 = { "anyOf": [{ "$ref": "#/definitions/rotate" }, { "type": "array", "items": { "$ref": "#/definitions/rotate" }, "minItems": 0, "maxItems": 2 }] };
+const schema33 = { "type": "number", "minimum": -360, "maximum": 360 };
+function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; const _errs0 = errors; let valid0 = false; const _errs1 = errors; const _errs2 = errors; if (errors === _errs2) {
+    if ((typeof data == "number") && (isFinite(data))) {
+        if (data > 360 || isNaN(data)) {
+            const err0 = { instancePath, schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
+            }
+            errors++;
+        }
+        else {
+            if (data < -360 || isNaN(data)) {
+                const err1 = { instancePath, schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+    }
+    else {
+        const err2 = { instancePath, schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+} var _valid0 = _errs1 === errors; valid0 = valid0 || _valid0; if (!valid0) {
+    const _errs4 = errors;
+    if (errors === _errs4) {
+        if (Array.isArray(data)) {
+            if (data.length > 2) {
+                const err3 = { instancePath, schemaPath: "#/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            else {
+                if (data.length < 0) {
+                    const err4 = { instancePath, schemaPath: "#/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                }
+                else {
+                    var valid2 = true;
+                    const len0 = data.length;
+                    for (let i0 = 0; i0 < len0; i0++) {
+                        let data0 = data[i0];
+                        const _errs6 = errors;
+                        const _errs7 = errors;
+                        if (errors === _errs7) {
+                            if ((typeof data0 == "number") && (isFinite(data0))) {
+                                if (data0 > 360 || isNaN(data0)) {
+                                    const err5 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
                                     if (vErrors === null) {
-                                        vErrors = [err1];
+                                        vErrors = [err5];
                                     }
                                     else {
-                                        vErrors.push(err1);
+                                        vErrors.push(err5);
                                     }
                                     errors++;
                                 }
-                                var _valid0 = _errs12 === errors;
-                                if (_valid0) {
-                                    valid1 = true;
-                                    passing0 = 0;
-                                }
-                                const _errs15 = errors;
-                                if (errors === _errs15) {
-                                    if (Array.isArray(data4)) {
-                                        if (data4.length > 128) {
-                                            const err2 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                            if (vErrors === null) {
-                                                vErrors = [err2];
-                                            }
-                                            else {
-                                                vErrors.push(err2);
-                                            }
-                                            errors++;
-                                        }
-                                        else {
-                                            var valid3 = true;
-                                            const len0 = data4.length;
-                                            for (let i0 = 0; i0 < len0; i0++) {
-                                                let data5 = data4[i0];
-                                                const _errs17 = errors;
-                                                if (typeof data5 !== "string") {
-                                                    const err3 = { instancePath: instancePath + "/flip/" + i0, schemaPath: "#/definitions/flip/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err3];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err3);
-                                                    }
-                                                    errors++;
-                                                }
-                                                if (!((((data5 === "none") || (data5 === "horizontal")) || (data5 === "vertical")) || (data5 === "both"))) {
-                                                    const err4 = { instancePath: instancePath + "/flip/" + i0, schemaPath: "#/definitions/flip/enum", keyword: "enum", params: { allowedValues: schema12.enum }, message: "must be equal to one of the allowed values" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err4];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err4);
-                                                    }
-                                                    errors++;
-                                                }
-                                                var valid3 = _errs17 === errors;
-                                                if (!valid3) {
-                                                    break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        const err5 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                else {
+                                    if (data0 < -360 || isNaN(data0)) {
+                                        const err6 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
                                         if (vErrors === null) {
-                                            vErrors = [err5];
+                                            vErrors = [err6];
                                         }
                                         else {
-                                            vErrors.push(err5);
+                                            vErrors.push(err6);
                                         }
                                         errors++;
                                     }
                                 }
-                                var _valid0 = _errs15 === errors;
-                                if (_valid0 && valid1) {
-                                    valid1 = false;
-                                    passing0 = [passing0, 1];
+                            }
+                            else {
+                                const err7 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                if (vErrors === null) {
+                                    vErrors = [err7];
                                 }
                                 else {
-                                    if (_valid0) {
-                                        valid1 = true;
-                                        passing0 = 1;
-                                    }
+                                    vErrors.push(err7);
                                 }
-                                if (!valid1) {
-                                    const err6 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                                errors++;
+                            }
+                        }
+                        var valid2 = _errs6 === errors;
+                        if (!valid2) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const err8 = { instancePath, schemaPath: "#/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = valid0 || _valid0;
+} if (!valid0) {
+    const err9 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+        vErrors = [err9];
+    }
+    else {
+        vErrors.push(err9);
+    }
+    errors++;
+    validate13.errors = vErrors;
+    return false;
+}
+else {
+    errors = _errs0;
+    if (vErrors !== null) {
+        if (_errs0) {
+            vErrors.length = _errs0;
+        }
+        else {
+            vErrors = null;
+        }
+    }
+} validate13.errors = vErrors; return errors === 0; }
+const schema35 = { "anyOf": [{ "$ref": "#/definitions/translate" }, { "type": "array", "items": { "$ref": "#/definitions/translate" }, "minItems": 0, "maxItems": 2 }] };
+const schema36 = { "type": "number", "minimum": -1000, "maximum": 1000 };
+function validate16(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; const _errs0 = errors; let valid0 = false; const _errs1 = errors; const _errs2 = errors; if (errors === _errs2) {
+    if ((typeof data == "number") && (isFinite(data))) {
+        if (data > 1000 || isNaN(data)) {
+            const err0 = { instancePath, schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
+            }
+            errors++;
+        }
+        else {
+            if (data < -1000 || isNaN(data)) {
+                const err1 = { instancePath, schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -1000 }, message: "must be >= -1000" };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                }
+                else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
+    }
+    else {
+        const err2 = { instancePath, schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+            vErrors = [err2];
+        }
+        else {
+            vErrors.push(err2);
+        }
+        errors++;
+    }
+} var _valid0 = _errs1 === errors; valid0 = valid0 || _valid0; if (!valid0) {
+    const _errs4 = errors;
+    if (errors === _errs4) {
+        if (Array.isArray(data)) {
+            if (data.length > 2) {
+                const err3 = { instancePath, schemaPath: "#/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            else {
+                if (data.length < 0) {
+                    const err4 = { instancePath, schemaPath: "#/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                }
+                else {
+                    var valid2 = true;
+                    const len0 = data.length;
+                    for (let i0 = 0; i0 < len0; i0++) {
+                        let data0 = data[i0];
+                        const _errs6 = errors;
+                        const _errs7 = errors;
+                        if (errors === _errs7) {
+                            if ((typeof data0 == "number") && (isFinite(data0))) {
+                                if (data0 > 1000 || isNaN(data0)) {
+                                    const err5 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
                                     if (vErrors === null) {
-                                        vErrors = [err6];
+                                        vErrors = [err5];
                                     }
                                     else {
-                                        vErrors.push(err6);
+                                        vErrors.push(err5);
                                     }
                                     errors++;
-                                    validate10.errors = vErrors;
-                                    return false;
                                 }
                                 else {
-                                    errors = _errs11;
-                                    if (vErrors !== null) {
-                                        if (_errs11) {
-                                            vErrors.length = _errs11;
+                                    if (data0 < -1000 || isNaN(data0)) {
+                                        const err6 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -1000 }, message: "must be >= -1000" };
+                                        if (vErrors === null) {
+                                            vErrors = [err6];
                                         }
                                         else {
-                                            vErrors = null;
+                                            vErrors.push(err6);
                                         }
+                                        errors++;
                                     }
                                 }
-                                var valid0 = _errs10 === errors;
                             }
                             else {
-                                var valid0 = true;
+                                const err7 = { instancePath: instancePath + "/" + i0, schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                if (vErrors === null) {
+                                    vErrors = [err7];
+                                }
+                                else {
+                                    vErrors.push(err7);
+                                }
+                                errors++;
                             }
-                            if (valid0) {
-                                if (data.fontFamily !== undefined) {
-                                    let data6 = data.fontFamily;
-                                    const _errs20 = errors;
-                                    const _errs21 = errors;
-                                    let valid5 = false;
-                                    let passing1 = null;
-                                    const _errs22 = errors;
-                                    const _errs23 = errors;
-                                    if (errors === _errs23) {
-                                        if (typeof data6 === "string") {
-                                            if (!pattern9.test(data6)) {
-                                                const err7 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/definitions/fontFamilyName/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z0-9 _\\-]+$" }, message: "must match pattern \"" + "^[a-zA-Z0-9 _\\-]+$" + "\"" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err7];
-                                                }
-                                                else {
-                                                    vErrors.push(err7);
-                                                }
-                                                errors++;
-                                            }
-                                        }
-                                        else {
-                                            const err8 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/definitions/fontFamilyName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                            if (vErrors === null) {
-                                                vErrors = [err8];
-                                            }
-                                            else {
-                                                vErrors.push(err8);
-                                            }
-                                            errors++;
-                                        }
-                                    }
-                                    var _valid1 = _errs22 === errors;
-                                    if (_valid1) {
-                                        valid5 = true;
-                                        passing1 = 0;
-                                    }
-                                    const _errs25 = errors;
-                                    if (errors === _errs25) {
-                                        if (Array.isArray(data6)) {
-                                            if (data6.length > 128) {
-                                                const err9 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err9];
-                                                }
-                                                else {
-                                                    vErrors.push(err9);
-                                                }
-                                                errors++;
-                                            }
-                                            else {
-                                                var valid7 = true;
-                                                const len1 = data6.length;
-                                                for (let i1 = 0; i1 < len1; i1++) {
-                                                    let data7 = data6[i1];
-                                                    const _errs27 = errors;
-                                                    const _errs28 = errors;
-                                                    if (errors === _errs28) {
-                                                        if (typeof data7 === "string") {
-                                                            if (!pattern9.test(data7)) {
-                                                                const err10 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/definitions/fontFamilyName/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z0-9 _\\-]+$" }, message: "must match pattern \"" + "^[a-zA-Z0-9 _\\-]+$" + "\"" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err10];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err10);
-                                                                }
-                                                                errors++;
-                                                            }
-                                                        }
-                                                        else {
-                                                            const err11 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/definitions/fontFamilyName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err11];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err11);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                    }
-                                                    var valid7 = _errs27 === errors;
-                                                    if (!valid7) {
-                                                        break;
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        else {
-                                            const err12 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
-                                            if (vErrors === null) {
-                                                vErrors = [err12];
-                                            }
-                                            else {
-                                                vErrors.push(err12);
-                                            }
-                                            errors++;
-                                        }
-                                    }
-                                    var _valid1 = _errs25 === errors;
-                                    if (_valid1 && valid5) {
-                                        valid5 = false;
-                                        passing1 = [passing1, 1];
+                        }
+                        var valid2 = _errs6 === errors;
+                        if (!valid2) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const err8 = { instancePath, schemaPath: "#/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+                vErrors = [err8];
+            }
+            else {
+                vErrors.push(err8);
+            }
+            errors++;
+        }
+    }
+    var _valid0 = _errs4 === errors;
+    valid0 = valid0 || _valid0;
+} if (!valid0) {
+    const err9 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+        vErrors = [err9];
+    }
+    else {
+        vErrors.push(err9);
+    }
+    errors++;
+    validate16.errors = vErrors;
+    return false;
+}
+else {
+    errors = _errs0;
+    if (vErrors !== null) {
+        if (_errs0) {
+            vErrors.length = _errs0;
+        }
+        else {
+            vErrors = null;
+        }
+    }
+} validate16.errors = vErrors; return errors === 0; }
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { /*# sourceURL="https://cdn.hopjs.net/npm/@dicebear/schema@0.14.1/dist/options.min.json" */ ; let vErrors = null; let errors = 0; if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (Object.keys(data).length > 512) {
+            validate10.errors = [{ instancePath, schemaPath: "#/maxProperties", keyword: "maxProperties", params: { limit: 512 }, message: "must NOT have more than 512 properties" }];
+            return false;
+        }
+        else {
+            for (const key0 in data) {
+                const _errs1 = errors;
+                if (typeof key0 === "string") {
+                    if (func2(key0) > 128) {
+                        const err0 = { instancePath, schemaPath: "#/propertyNames/maxLength", keyword: "maxLength", params: { limit: 128 }, message: "must NOT have more than 128 characters", propertyName: key0 };
+                        if (vErrors === null) {
+                            vErrors = [err0];
+                        }
+                        else {
+                            vErrors.push(err0);
+                        }
+                        errors++;
+                    }
+                }
+                var valid0 = _errs1 === errors;
+                if (!valid0) {
+                    const err1 = { instancePath, schemaPath: "#/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+                    if (vErrors === null) {
+                        vErrors = [err1];
+                    }
+                    else {
+                        vErrors.push(err1);
+                    }
+                    errors++;
+                    validate10.errors = vErrors;
+                    return false;
+                    break;
+                }
+            }
+            if (valid0) {
+                const _errs2 = errors;
+                for (const key1 in data) {
+                    if (!((((((((((func3.call(schema11.properties, key1)) || (pattern0.test(key1))) || (pattern1.test(key1))) || (pattern2.test(key1))) || (pattern3.test(key1))) || (pattern4.test(key1))) || (pattern5.test(key1))) || (pattern6.test(key1))) || (pattern7.test(key1))) || (pattern8.test(key1)))) {
+                        validate10.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" }];
+                        return false;
+                        break;
+                    }
+                }
+                if (_errs2 === errors) {
+                    if (data.seed !== undefined) {
+                        let data0 = data.seed;
+                        const _errs3 = errors;
+                        if (errors === _errs3) {
+                            if (typeof data0 === "string") {
+                                if (func2(data0) > 1024) {
+                                    validate10.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
+                                    return false;
+                                }
+                            }
+                            else {
+                                validate10.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                return false;
+                            }
+                        }
+                        var valid1 = _errs3 === errors;
+                    }
+                    else {
+                        var valid1 = true;
+                    }
+                    if (valid1) {
+                        if (data.size !== undefined) {
+                            let data1 = data.size;
+                            const _errs5 = errors;
+                            if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
+                                validate10.errors = [{ instancePath: instancePath + "/size", schemaPath: "#/properties/size/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
+                                return false;
+                            }
+                            if (errors === _errs5) {
+                                if ((typeof data1 == "number") && (isFinite(data1))) {
+                                    if (data1 > 4096 || isNaN(data1)) {
+                                        validate10.errors = [{ instancePath: instancePath + "/size", schemaPath: "#/properties/size/maximum", keyword: "maximum", params: { comparison: "<=", limit: 4096 }, message: "must be <= 4096" }];
+                                        return false;
                                     }
                                     else {
-                                        if (_valid1) {
-                                            valid5 = true;
-                                            passing1 = 1;
+                                        if (data1 < 1 || isNaN(data1)) {
+                                            validate10.errors = [{ instancePath: instancePath + "/size", schemaPath: "#/properties/size/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" }];
+                                            return false;
                                         }
                                     }
-                                    if (!valid5) {
-                                        const err13 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/oneOf", keyword: "oneOf", params: { passingSchemas: passing1 }, message: "must match exactly one schema in oneOf" };
-                                        if (vErrors === null) {
-                                            vErrors = [err13];
+                                }
+                            }
+                            var valid1 = _errs5 === errors;
+                        }
+                        else {
+                            var valid1 = true;
+                        }
+                        if (valid1) {
+                            if (data.idRandomization !== undefined) {
+                                const _errs7 = errors;
+                                if (typeof data.idRandomization !== "boolean") {
+                                    validate10.errors = [{ instancePath: instancePath + "/idRandomization", schemaPath: "#/properties/idRandomization/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                                    return false;
+                                }
+                                var valid1 = _errs7 === errors;
+                            }
+                            else {
+                                var valid1 = true;
+                            }
+                            if (valid1) {
+                                if (data.title !== undefined) {
+                                    let data3 = data.title;
+                                    const _errs9 = errors;
+                                    if (errors === _errs9) {
+                                        if (typeof data3 === "string") {
+                                            if (func2(data3) > 256) {
+                                                validate10.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                                return false;
+                                            }
                                         }
                                         else {
-                                            vErrors.push(err13);
+                                            validate10.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
                                         }
-                                        errors++;
-                                        validate10.errors = vErrors;
-                                        return false;
                                     }
-                                    else {
-                                        errors = _errs21;
-                                        if (vErrors !== null) {
-                                            if (_errs21) {
-                                                vErrors.length = _errs21;
+                                    var valid1 = _errs9 === errors;
+                                }
+                                else {
+                                    var valid1 = true;
+                                }
+                                if (valid1) {
+                                    if (data.flip !== undefined) {
+                                        let data4 = data.flip;
+                                        const _errs11 = errors;
+                                        const _errs12 = errors;
+                                        let valid2 = false;
+                                        const _errs13 = errors;
+                                        if (typeof data4 !== "string") {
+                                            const err2 = { instancePath: instancePath + "/flip", schemaPath: "#/definitions/flip/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                            if (vErrors === null) {
+                                                vErrors = [err2];
                                             }
                                             else {
-                                                vErrors = null;
+                                                vErrors.push(err2);
                                             }
+                                            errors++;
                                         }
-                                    }
-                                    var valid0 = _errs20 === errors;
-                                }
-                                else {
-                                    var valid0 = true;
-                                }
-                                if (valid0) {
-                                    if (data.fontWeight !== undefined) {
-                                        let data8 = data.fontWeight;
-                                        const _errs30 = errors;
-                                        const _errs31 = errors;
-                                        let valid9 = false;
-                                        let passing2 = null;
-                                        const _errs32 = errors;
-                                        const _errs33 = errors;
-                                        if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
-                                            const err14 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                        if (!((((data4 === "none") || (data4 === "horizontal")) || (data4 === "vertical")) || (data4 === "both"))) {
+                                            const err3 = { instancePath: instancePath + "/flip", schemaPath: "#/definitions/flip/enum", keyword: "enum", params: { allowedValues: schema12.enum }, message: "must be equal to one of the allowed values" };
                                             if (vErrors === null) {
-                                                vErrors = [err14];
+                                                vErrors = [err3];
                                             }
                                             else {
-                                                vErrors.push(err14);
+                                                vErrors.push(err3);
                                             }
                                             errors++;
                                         }
-                                        if (errors === _errs33) {
-                                            if ((typeof data8 == "number") && (isFinite(data8))) {
-                                                if (data8 > 1000 || isNaN(data8)) {
-                                                    const err15 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err15];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err15);
-                                                    }
-                                                    errors++;
-                                                }
-                                                else {
-                                                    if (data8 < 1 || isNaN(data8)) {
-                                                        const err16 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                        var _valid0 = _errs13 === errors;
+                                        valid2 = valid2 || _valid0;
+                                        if (!valid2) {
+                                            const _errs16 = errors;
+                                            if (errors === _errs16) {
+                                                if (Array.isArray(data4)) {
+                                                    if (data4.length > 128) {
+                                                        const err4 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                         if (vErrors === null) {
-                                                            vErrors = [err16];
+                                                            vErrors = [err4];
                                                         }
                                                         else {
-                                                            vErrors.push(err16);
+                                                            vErrors.push(err4);
                                                         }
                                                         errors++;
                                                     }
-                                                }
-                                            }
-                                        }
-                                        var _valid2 = _errs32 === errors;
-                                        if (_valid2) {
-                                            valid9 = true;
-                                            passing2 = 0;
-                                        }
-                                        const _errs35 = errors;
-                                        if (errors === _errs35) {
-                                            if (Array.isArray(data8)) {
-                                                if (data8.length > 128) {
-                                                    const err17 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err17];
-                                                    }
                                                     else {
-                                                        vErrors.push(err17);
-                                                    }
-                                                    errors++;
-                                                }
-                                                else {
-                                                    var valid11 = true;
-                                                    const len2 = data8.length;
-                                                    for (let i2 = 0; i2 < len2; i2++) {
-                                                        let data9 = data8[i2];
-                                                        const _errs37 = errors;
-                                                        const _errs38 = errors;
-                                                        if (!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) {
-                                                            const err18 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                                        if (data4.length < 0) {
+                                                            const err5 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
                                                             if (vErrors === null) {
-                                                                vErrors = [err18];
+                                                                vErrors = [err5];
                                                             }
                                                             else {
-                                                                vErrors.push(err18);
+                                                                vErrors.push(err5);
                                                             }
                                                             errors++;
                                                         }
-                                                        if (errors === _errs38) {
-                                                            if ((typeof data9 == "number") && (isFinite(data9))) {
-                                                                if (data9 > 1000 || isNaN(data9)) {
-                                                                    const err19 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
+                                                        else {
+                                                            var valid4 = true;
+                                                            const len0 = data4.length;
+                                                            for (let i0 = 0; i0 < len0; i0++) {
+                                                                let data5 = data4[i0];
+                                                                const _errs18 = errors;
+                                                                if (typeof data5 !== "string") {
+                                                                    const err6 = { instancePath: instancePath + "/flip/" + i0, schemaPath: "#/definitions/flip/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                                     if (vErrors === null) {
-                                                                        vErrors = [err19];
+                                                                        vErrors = [err6];
                                                                     }
                                                                     else {
-                                                                        vErrors.push(err19);
+                                                                        vErrors.push(err6);
                                                                     }
                                                                     errors++;
                                                                 }
-                                                                else {
-                                                                    if (data9 < 1 || isNaN(data9)) {
-                                                                        const err20 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err20];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err20);
-                                                                        }
-                                                                        errors++;
+                                                                if (!((((data5 === "none") || (data5 === "horizontal")) || (data5 === "vertical")) || (data5 === "both"))) {
+                                                                    const err7 = { instancePath: instancePath + "/flip/" + i0, schemaPath: "#/definitions/flip/enum", keyword: "enum", params: { allowedValues: schema12.enum }, message: "must be equal to one of the allowed values" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err7];
+                                                                    }
+                                                                    else {
+                                                                        vErrors.push(err7);
                                                                     }
+                                                                    errors++;
+                                                                }
+                                                                var valid4 = _errs18 === errors;
+                                                                if (!valid4) {
+                                                                    break;
                                                                 }
                                                             }
                                                         }
-                                                        var valid11 = _errs37 === errors;
-                                                        if (!valid11) {
-                                                            break;
-                                                        }
                                                     }
                                                 }
-                                            }
-                                            else {
-                                                const err21 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err21];
-                                                }
                                                 else {
-                                                    vErrors.push(err21);
+                                                    const err8 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err8];
+                                                    }
+                                                    else {
+                                                        vErrors.push(err8);
+                                                    }
+                                                    errors++;
                                                 }
-                                                errors++;
                                             }
+                                            var _valid0 = _errs16 === errors;
+                                            valid2 = valid2 || _valid0;
                                         }
-                                        var _valid2 = _errs35 === errors;
-                                        if (_valid2 && valid9) {
-                                            valid9 = false;
-                                            passing2 = [passing2, 1];
-                                        }
-                                        else {
-                                            if (_valid2) {
-                                                valid9 = true;
-                                                passing2 = 1;
-                                            }
-                                        }
-                                        if (!valid9) {
-                                            const err22 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/oneOf", keyword: "oneOf", params: { passingSchemas: passing2 }, message: "must match exactly one schema in oneOf" };
+                                        if (!valid2) {
+                                            const err9 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
                                             if (vErrors === null) {
-                                                vErrors = [err22];
+                                                vErrors = [err9];
                                             }
                                             else {
-                                                vErrors.push(err22);
+                                                vErrors.push(err9);
                                             }
                                             errors++;
                                             validate10.errors = vErrors;
                                             return false;
                                         }
                                         else {
-                                            errors = _errs31;
+                                            errors = _errs12;
                                             if (vErrors !== null) {
-                                                if (_errs31) {
-                                                    vErrors.length = _errs31;
+                                                if (_errs12) {
+                                                    vErrors.length = _errs12;
                                                 }
                                                 else {
                                                     vErrors = null;
                                                 }
                                             }
                                         }
-                                        var valid0 = _errs30 === errors;
+                                        var valid1 = _errs11 === errors;
                                     }
                                     else {
-                                        var valid0 = true;
+                                        var valid1 = true;
                                     }
-                                    if (valid0) {
-                                        if (data.scale !== undefined) {
-                                            let data10 = data.scale;
-                                            const _errs40 = errors;
-                                            const _errs41 = errors;
-                                            let valid13 = false;
-                                            let passing3 = null;
-                                            const _errs42 = errors;
-                                            const _errs43 = errors;
-                                            if (errors === _errs43) {
-                                                if ((typeof data10 == "number") && (isFinite(data10))) {
-                                                    if (data10 < 0 || isNaN(data10)) {
-                                                        const err23 = { instancePath: instancePath + "/scale", schemaPath: "#/definitions/scale/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                    if (valid1) {
+                                        if (data.fontFamily !== undefined) {
+                                            let data6 = data.fontFamily;
+                                            const _errs21 = errors;
+                                            const _errs22 = errors;
+                                            let valid6 = false;
+                                            const _errs23 = errors;
+                                            const _errs24 = errors;
+                                            if (errors === _errs24) {
+                                                if (typeof data6 === "string") {
+                                                    if (func2(data6) > 256) {
+                                                        const err10 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/definitions/fontFamilyName/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" };
                                                         if (vErrors === null) {
-                                                            vErrors = [err23];
+                                                            vErrors = [err10];
                                                         }
                                                         else {
-                                                            vErrors.push(err23);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                }
-                                                else {
-                                                    const err24 = { instancePath: instancePath + "/scale", schemaPath: "#/definitions/scale/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                    if (vErrors === null) {
-                                                        vErrors = [err24];
-                                                    }
-                                                    else {
-                                                        vErrors.push(err24);
-                                                    }
-                                                    errors++;
-                                                }
-                                            }
-                                            var _valid3 = _errs42 === errors;
-                                            if (_valid3) {
-                                                valid13 = true;
-                                                passing3 = 0;
-                                            }
-                                            const _errs45 = errors;
-                                            if (errors === _errs45) {
-                                                if (Array.isArray(data10)) {
-                                                    if (data10.length > 2) {
-                                                        const err25 = { instancePath: instancePath + "/scale", schemaPath: "#/properties/scale/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err25];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err25);
+                                                            vErrors.push(err10);
                                                         }
                                                         errors++;
                                                     }
                                                     else {
-                                                        var valid15 = true;
-                                                        const len3 = data10.length;
-                                                        for (let i3 = 0; i3 < len3; i3++) {
-                                                            let data11 = data10[i3];
-                                                            const _errs47 = errors;
-                                                            const _errs48 = errors;
-                                                            if (errors === _errs48) {
-                                                                if ((typeof data11 == "number") && (isFinite(data11))) {
-                                                                    if (data11 < 0 || isNaN(data11)) {
-                                                                        const err26 = { instancePath: instancePath + "/scale/" + i3, schemaPath: "#/definitions/scale/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err26];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err26);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                else {
-                                                                    const err27 = { instancePath: instancePath + "/scale/" + i3, schemaPath: "#/definitions/scale/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err27];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err27);
-                                                                    }
-                                                                    errors++;
-                                                                }
+                                                        if (!pattern9.test(data6)) {
+                                                            const err11 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/definitions/fontFamilyName/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$" }, message: "must match pattern \"" + "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$" + "\"" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err11];
                                                             }
-                                                            var valid15 = _errs47 === errors;
-                                                            if (!valid15) {
-                                                                break;
+                                                            else {
+                                                                vErrors.push(err11);
                                                             }
+                                                            errors++;
                                                         }
                                                     }
                                                 }
                                                 else {
-                                                    const err28 = { instancePath: instancePath + "/scale", schemaPath: "#/properties/scale/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                    const err12 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/definitions/fontFamilyName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                     if (vErrors === null) {
-                                                        vErrors = [err28];
+                                                        vErrors = [err12];
                                                     }
                                                     else {
-                                                        vErrors.push(err28);
+                                                        vErrors.push(err12);
                                                     }
                                                     errors++;
                                                 }
                                             }
-                                            var _valid3 = _errs45 === errors;
-                                            if (_valid3 && valid13) {
-                                                valid13 = false;
-                                                passing3 = [passing3, 1];
-                                            }
-                                            else {
-                                                if (_valid3) {
-                                                    valid13 = true;
-                                                    passing3 = 1;
-                                                }
-                                            }
-                                            if (!valid13) {
-                                                const err29 = { instancePath: instancePath + "/scale", schemaPath: "#/properties/scale/oneOf", keyword: "oneOf", params: { passingSchemas: passing3 }, message: "must match exactly one schema in oneOf" };
-                                                if (vErrors === null) {
-                                                    vErrors = [err29];
-                                                }
-                                                else {
-                                                    vErrors.push(err29);
-                                                }
-                                                errors++;
-                                                validate10.errors = vErrors;
-                                                return false;
-                                            }
-                                            else {
-                                                errors = _errs41;
-                                                if (vErrors !== null) {
-                                                    if (_errs41) {
-                                                        vErrors.length = _errs41;
-                                                    }
-                                                    else {
-                                                        vErrors = null;
-                                                    }
-                                                }
-                                            }
-                                            var valid0 = _errs40 === errors;
-                                        }
-                                        else {
-                                            var valid0 = true;
-                                        }
-                                        if (valid0) {
-                                            if (data.borderRadius !== undefined) {
-                                                let data12 = data.borderRadius;
-                                                const _errs50 = errors;
-                                                const _errs51 = errors;
-                                                let valid17 = false;
-                                                let passing4 = null;
-                                                const _errs52 = errors;
-                                                const _errs53 = errors;
-                                                if (errors === _errs53) {
-                                                    if ((typeof data12 == "number") && (isFinite(data12))) {
-                                                        if (data12 > 50 || isNaN(data12)) {
-                                                            const err30 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/maximum", keyword: "maximum", params: { comparison: "<=", limit: 50 }, message: "must be <= 50" };
-                                                            if (vErrors === null) {
-                                                                vErrors = [err30];
-                                                            }
-                                                            else {
-                                                                vErrors.push(err30);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                        else {
-                                                            if (data12 < 0 || isNaN(data12)) {
-                                                                const err31 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err31];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err31);
-                                                                }
-                                                                errors++;
-                                                            }
-                                                        }
-                                                    }
-                                                    else {
-                                                        const err32 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                        if (vErrors === null) {
-                                                            vErrors = [err32];
-                                                        }
-                                                        else {
-                                                            vErrors.push(err32);
-                                                        }
-                                                        errors++;
-                                                    }
-                                                }
-                                                var _valid4 = _errs52 === errors;
-                                                if (_valid4) {
-                                                    valid17 = true;
-                                                    passing4 = 0;
-                                                }
-                                                const _errs55 = errors;
-                                                if (errors === _errs55) {
-                                                    if (Array.isArray(data12)) {
-                                                        if (data12.length > 2) {
-                                                            const err33 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                                            var _valid1 = _errs23 === errors;
+                                            valid6 = valid6 || _valid1;
+                                            if (!valid6) {
+                                                const _errs26 = errors;
+                                                if (errors === _errs26) {
+                                                    if (Array.isArray(data6)) {
+                                                        if (data6.length > 128) {
+                                                            const err13 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                             if (vErrors === null) {
-                                                                vErrors = [err33];
+                                                                vErrors = [err13];
                                                             }
                                                             else {
-                                                                vErrors.push(err33);
-                                                            }
-                                                            errors++;
-                                                        }
-                                                        else {
-                                                            var valid19 = true;
-                                                            const len4 = data12.length;
-                                                            for (let i4 = 0; i4 < len4; i4++) {
-                                                                let data13 = data12[i4];
-                                                                const _errs57 = errors;
-                                                                const _errs58 = errors;
-                                                                if (errors === _errs58) {
-                                                                    if ((typeof data13 == "number") && (isFinite(data13))) {
-                                                                        if (data13 > 50 || isNaN(data13)) {
-                                                                            const err34 = { instancePath: instancePath + "/borderRadius/" + i4, schemaPath: "#/definitions/borderRadius/maximum", keyword: "maximum", params: { comparison: "<=", limit: 50 }, message: "must be <= 50" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err34];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err34);
-                                                                            }
-                                                                            errors++;
-                                                                        }
-                                                                        else {
-                                                                            if (data13 < 0 || isNaN(data13)) {
-                                                                                const err35 = { instancePath: instancePath + "/borderRadius/" + i4, schemaPath: "#/definitions/borderRadius/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                                                vErrors.push(err13);
+                                                            }
+                                                            errors++;
+                                                        }
+                                                        else {
+                                                            if (data6.length < 0) {
+                                                                const err14 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                                                                if (vErrors === null) {
+                                                                    vErrors = [err14];
+                                                                }
+                                                                else {
+                                                                    vErrors.push(err14);
+                                                                }
+                                                                errors++;
+                                                            }
+                                                            else {
+                                                                var valid8 = true;
+                                                                const len1 = data6.length;
+                                                                for (let i1 = 0; i1 < len1; i1++) {
+                                                                    let data7 = data6[i1];
+                                                                    const _errs28 = errors;
+                                                                    const _errs29 = errors;
+                                                                    if (errors === _errs29) {
+                                                                        if (typeof data7 === "string") {
+                                                                            if (func2(data7) > 256) {
+                                                                                const err15 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/definitions/fontFamilyName/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" };
                                                                                 if (vErrors === null) {
-                                                                                    vErrors = [err35];
+                                                                                    vErrors = [err15];
                                                                                 }
                                                                                 else {
-                                                                                    vErrors.push(err35);
+                                                                                    vErrors.push(err15);
                                                                                 }
                                                                                 errors++;
                                                                             }
-                                                                        }
-                                                                    }
-                                                                    else {
-                                                                        const err36 = { instancePath: instancePath + "/borderRadius/" + i4, schemaPath: "#/definitions/borderRadius/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err36];
+                                                                            else {
+                                                                                if (!pattern9.test(data7)) {
+                                                                                    const err16 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/definitions/fontFamilyName/pattern", keyword: "pattern", params: { pattern: "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$" }, message: "must match pattern \"" + "^[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*(, ?[a-zA-Z0-9_\\-]+( [a-zA-Z0-9_\\-]+)*)*$" + "\"" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err16];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err16);
+                                                                                    }
+                                                                                    errors++;
+                                                                                }
+                                                                            }
                                                                         }
                                                                         else {
-                                                                            vErrors.push(err36);
+                                                                            const err17 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/definitions/fontFamilyName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err17];
+                                                                            }
+                                                                            else {
+                                                                                vErrors.push(err17);
+                                                                            }
+                                                                            errors++;
                                                                         }
-                                                                        errors++;
                                                                     }
-                                                                }
-                                                                var valid19 = _errs57 === errors;
-                                                                if (!valid19) {
-                                                                    break;
+                                                                    var valid8 = _errs28 === errors;
+                                                                    if (!valid8) {
+                                                                        break;
+                                                                    }
                                                                 }
                                                             }
                                                         }
                                                     }
                                                     else {
-                                                        const err37 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                        const err18 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                         if (vErrors === null) {
-                                                            vErrors = [err37];
+                                                            vErrors = [err18];
                                                         }
                                                         else {
-                                                            vErrors.push(err37);
+                                                            vErrors.push(err18);
                                                         }
                                                         errors++;
                                                     }
                                                 }
-                                                var _valid4 = _errs55 === errors;
-                                                if (_valid4 && valid17) {
-                                                    valid17 = false;
-                                                    passing4 = [passing4, 1];
+                                                var _valid1 = _errs26 === errors;
+                                                valid6 = valid6 || _valid1;
+                                            }
+                                            if (!valid6) {
+                                                const err19 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/properties/fontFamily/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                if (vErrors === null) {
+                                                    vErrors = [err19];
                                                 }
                                                 else {
-                                                    if (_valid4) {
-                                                        valid17 = true;
-                                                        passing4 = 1;
+                                                    vErrors.push(err19);
+                                                }
+                                                errors++;
+                                                validate10.errors = vErrors;
+                                                return false;
+                                            }
+                                            else {
+                                                errors = _errs22;
+                                                if (vErrors !== null) {
+                                                    if (_errs22) {
+                                                        vErrors.length = _errs22;
+                                                    }
+                                                    else {
+                                                        vErrors = null;
                                                     }
                                                 }
-                                                if (!valid17) {
-                                                    const err38 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/oneOf", keyword: "oneOf", params: { passingSchemas: passing4 }, message: "must match exactly one schema in oneOf" };
+                                            }
+                                            var valid1 = _errs21 === errors;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                        }
+                                        if (valid1) {
+                                            if (data.fontWeight !== undefined) {
+                                                let data8 = data.fontWeight;
+                                                const _errs31 = errors;
+                                                const _errs32 = errors;
+                                                let valid10 = false;
+                                                const _errs33 = errors;
+                                                const _errs34 = errors;
+                                                if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
+                                                    const err20 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
                                                     if (vErrors === null) {
-                                                        vErrors = [err38];
+                                                        vErrors = [err20];
                                                     }
                                                     else {
-                                                        vErrors.push(err38);
+                                                        vErrors.push(err20);
                                                     }
                                                     errors++;
-                                                    validate10.errors = vErrors;
-                                                    return false;
                                                 }
-                                                else {
-                                                    errors = _errs51;
-                                                    if (vErrors !== null) {
-                                                        if (_errs51) {
-                                                            vErrors.length = _errs51;
+                                                if (errors === _errs34) {
+                                                    if ((typeof data8 == "number") && (isFinite(data8))) {
+                                                        if (data8 > 1000 || isNaN(data8)) {
+                                                            const err21 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err21];
+                                                            }
+                                                            else {
+                                                                vErrors.push(err21);
+                                                            }
+                                                            errors++;
                                                         }
                                                         else {
-                                                            vErrors = null;
-                                                        }
-                                                    }
-                                                }
-                                                var valid0 = _errs50 === errors;
-                                            }
-                                            else {
-                                                var valid0 = true;
-                                            }
-                                            if (valid0) {
-                                                var valid21 = true;
-                                                for (const key1 in data) {
-                                                    if (pattern0.test(key1)) {
-                                                        let data14 = data[key1];
-                                                        const _errs60 = errors;
-                                                        if (errors === _errs60) {
-                                                            if ((typeof data14 == "number") && (isFinite(data14))) {
-                                                                if (data14 > 100 || isNaN(data14)) {
-                                                                    validate10.errors = [{ instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" }];
-                                                                    return false;
+                                                            if (data8 < 1 || isNaN(data8)) {
+                                                                const err22 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/definitions/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                                if (vErrors === null) {
+                                                                    vErrors = [err22];
                                                                 }
                                                                 else {
-                                                                    if (data14 < 0 || isNaN(data14)) {
-                                                                        validate10.errors = [{ instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
-                                                                        return false;
-                                                                    }
+                                                                    vErrors.push(err22);
                                                                 }
-                                                            }
-                                                            else {
-                                                                validate10.errors = [{ instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
-                                                                return false;
+                                                                errors++;
                                                             }
                                                         }
-                                                        var valid21 = _errs60 === errors;
-                                                        if (!valid21) {
-                                                            break;
-                                                        }
                                                     }
                                                 }
-                                                if (valid21) {
-                                                    var valid21 = true;
-                                                    for (const key2 in data) {
-                                                        if (pattern1.test(key2)) {
-                                                            let data15 = data[key2];
-                                                            const _errs62 = errors;
-                                                            const _errs63 = errors;
-                                                            let valid22 = false;
-                                                            let passing5 = null;
-                                                            const _errs64 = errors;
-                                                            if (typeof data15 !== "string") {
-                                                                const err39 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                var _valid2 = _errs33 === errors;
+                                                valid10 = valid10 || _valid2;
+                                                if (!valid10) {
+                                                    const _errs36 = errors;
+                                                    if (errors === _errs36) {
+                                                        if (Array.isArray(data8)) {
+                                                            if (data8.length > 128) {
+                                                                const err23 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                                 if (vErrors === null) {
-                                                                    vErrors = [err39];
+                                                                    vErrors = [err23];
                                                                 }
                                                                 else {
-                                                                    vErrors.push(err39);
+                                                                    vErrors.push(err23);
                                                                 }
                                                                 errors++;
                                                             }
-                                                            var _valid5 = _errs64 === errors;
-                                                            if (_valid5) {
-                                                                valid22 = true;
-                                                                passing5 = 0;
-                                                            }
-                                                            const _errs66 = errors;
-                                                            if (errors === _errs66) {
-                                                                if (Array.isArray(data15)) {
-                                                                    if (data15.length > 128) {
-                                                                        const err40 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err40];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err40);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                    else {
-                                                                        var valid23 = true;
-                                                                        const len5 = data15.length;
-                                                                        for (let i5 = 0; i5 < len5; i5++) {
-                                                                            const _errs68 = errors;
-                                                                            if (typeof data15[i5] !== "string") {
-                                                                                const err41 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i5, schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/1/items/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                                if (vErrors === null) {
-                                                                                    vErrors = [err41];
-                                                                                }
-                                                                                else {
-                                                                                    vErrors.push(err41);
-                                                                                }
-                                                                                errors++;
-                                                                            }
-                                                                            var valid23 = _errs68 === errors;
-                                                                            if (!valid23) {
-                                                                                break;
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                                else {
-                                                                    const err42 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                            else {
+                                                                if (data8.length < 0) {
+                                                                    const err24 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
                                                                     if (vErrors === null) {
-                                                                        vErrors = [err42];
+                                                                        vErrors = [err24];
                                                                     }
                                                                     else {
-                                                                        vErrors.push(err42);
+                                                                        vErrors.push(err24);
                                                                     }
                                                                     errors++;
                                                                 }
-                                                            }
-                                                            var _valid5 = _errs66 === errors;
-                                                            if (_valid5 && valid22) {
-                                                                valid22 = false;
-                                                                passing5 = [passing5, 1];
-                                                            }
-                                                            else {
-                                                                if (_valid5) {
-                                                                    valid22 = true;
-                                                                    passing5 = 1;
-                                                                }
-                                                                const _errs70 = errors;
-                                                                if (errors === _errs70) {
-                                                                    if (data15 && typeof data15 == "object" && !Array.isArray(data15)) {
-                                                                        if (Object.keys(data15).length > 128) {
-                                                                            const err43 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/maxProperties", keyword: "maxProperties", params: { limit: 128 }, message: "must NOT have more than 128 properties" };
+                                                                else {
+                                                                    var valid12 = true;
+                                                                    const len2 = data8.length;
+                                                                    for (let i2 = 0; i2 < len2; i2++) {
+                                                                        let data9 = data8[i2];
+                                                                        const _errs38 = errors;
+                                                                        const _errs39 = errors;
+                                                                        if (!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) {
+                                                                            const err25 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
                                                                             if (vErrors === null) {
-                                                                                vErrors = [err43];
+                                                                                vErrors = [err25];
                                                                             }
                                                                             else {
-                                                                                vErrors.push(err43);
+                                                                                vErrors.push(err25);
                                                                             }
                                                                             errors++;
                                                                         }
-                                                                        else {
-                                                                            for (const key3 in data15) {
-                                                                                const _errs72 = errors;
-                                                                                if (typeof key3 === "string") {
-                                                                                    if (!pattern13.test(key3)) {
-                                                                                        const err44 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/propertyNames/pattern", keyword: "pattern", params: { pattern: "^[a-z][a-zA-Z0-9]*$" }, message: "must match pattern \"" + "^[a-z][a-zA-Z0-9]*$" + "\"", propertyName: key3 };
-                                                                                        if (vErrors === null) {
-                                                                                            vErrors = [err44];
-                                                                                        }
-                                                                                        else {
-                                                                                            vErrors.push(err44);
-                                                                                        }
-                                                                                        errors++;
-                                                                                    }
-                                                                                }
-                                                                                var valid24 = _errs72 === errors;
-                                                                                if (!valid24) {
-                                                                                    const err45 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/propertyNames", keyword: "propertyNames", params: { propertyName: key3 }, message: "property name must be valid" };
+                                                                        if (errors === _errs39) {
+                                                                            if ((typeof data9 == "number") && (isFinite(data9))) {
+                                                                                if (data9 > 1000 || isNaN(data9)) {
+                                                                                    const err26 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err45];
+                                                                                        vErrors = [err26];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err45);
+                                                                                        vErrors.push(err26);
                                                                                     }
                                                                                     errors++;
-                                                                                    break;
                                                                                 }
-                                                                            }
-                                                                            if (valid24) {
-                                                                                for (const key4 in data15) {
-                                                                                    let data17 = data15[key4];
-                                                                                    const _errs74 = errors;
-                                                                                    if (errors === _errs74) {
-                                                                                        if ((typeof data17 == "number") && (isFinite(data17))) {
-                                                                                            if (data17 < 0 || isNaN(data17)) {
-                                                                                                const err46 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/additionalProperties/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
-                                                                                                if (vErrors === null) {
-                                                                                                    vErrors = [err46];
-                                                                                                }
-                                                                                                else {
-                                                                                                    vErrors.push(err46);
-                                                                                                }
-                                                                                                errors++;
-                                                                                            }
+                                                                                else {
+                                                                                    if (data9 < 1 || isNaN(data9)) {
+                                                                                        const err27 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/definitions/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err27];
                                                                                         }
                                                                                         else {
-                                                                                            const err47 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/additionalProperties/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err47];
-                                                                                            }
-                                                                                            else {
-                                                                                                vErrors.push(err47);
-                                                                                            }
-                                                                                            errors++;
+                                                                                            vErrors.push(err27);
                                                                                         }
-                                                                                    }
-                                                                                    var valid25 = _errs74 === errors;
-                                                                                    if (!valid25) {
-                                                                                        break;
+                                                                                        errors++;
                                                                                     }
                                                                                 }
                                                                             }
                                                                         }
-                                                                    }
-                                                                    else {
-                                                                        const err48 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf/2/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err48];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err48);
+                                                                        var valid12 = _errs38 === errors;
+                                                                        if (!valid12) {
+                                                                            break;
                                                                         }
-                                                                        errors++;
-                                                                    }
-                                                                }
-                                                                var _valid5 = _errs70 === errors;
-                                                                if (_valid5 && valid22) {
-                                                                    valid22 = false;
-                                                                    passing5 = [passing5, 2];
-                                                                }
-                                                                else {
-                                                                    if (_valid5) {
-                                                                        valid22 = true;
-                                                                        passing5 = 2;
                                                                     }
                                                                 }
                                                             }
-                                                            if (!valid22) {
-                                                                const err49 = { instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing5 }, message: "must match exactly one schema in oneOf" };
-                                                                if (vErrors === null) {
-                                                                    vErrors = [err49];
-                                                                }
-                                                                else {
-                                                                    vErrors.push(err49);
-                                                                }
-                                                                errors++;
-                                                                validate10.errors = vErrors;
-                                                                return false;
+                                                        }
+                                                        else {
+                                                            const err28 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err28];
                                                             }
                                                             else {
-                                                                errors = _errs63;
-                                                                if (vErrors !== null) {
-                                                                    if (_errs63) {
-                                                                        vErrors.length = _errs63;
-                                                                    }
-                                                                    else {
-                                                                        vErrors = null;
-                                                                    }
-                                                                }
-                                                            }
-                                                            var valid21 = _errs62 === errors;
-                                                            if (!valid21) {
-                                                                break;
+                                                                vErrors.push(err28);
                                                             }
+                                                            errors++;
                                                         }
                                                     }
-                                                    if (valid21) {
-                                                        var valid21 = true;
-                                                        for (const key5 in data) {
-                                                            if (pattern2.test(key5)) {
-                                                                let data18 = data[key5];
-                                                                const _errs76 = errors;
-                                                                const _errs77 = errors;
-                                                                let valid26 = false;
-                                                                let passing6 = null;
-                                                                const _errs78 = errors;
-                                                                const _errs79 = errors;
-                                                                if (errors === _errs79) {
-                                                                    if (typeof data18 === "string") {
-                                                                        if (!pattern15.test(data18)) {
-                                                                            const err50 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/color/pattern", keyword: "pattern", params: { pattern: "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, message: "must match pattern \"" + "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" + "\"" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err50];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err50);
-                                                                            }
-                                                                            errors++;
-                                                                        }
+                                                    var _valid2 = _errs36 === errors;
+                                                    valid10 = valid10 || _valid2;
+                                                }
+                                                if (!valid10) {
+                                                    const err29 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/properties/fontWeight/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err29];
+                                                    }
+                                                    else {
+                                                        vErrors.push(err29);
+                                                    }
+                                                    errors++;
+                                                    validate10.errors = vErrors;
+                                                    return false;
+                                                }
+                                                else {
+                                                    errors = _errs32;
+                                                    if (vErrors !== null) {
+                                                        if (_errs32) {
+                                                            vErrors.length = _errs32;
+                                                        }
+                                                        else {
+                                                            vErrors = null;
+                                                        }
+                                                    }
+                                                }
+                                                var valid1 = _errs31 === errors;
+                                            }
+                                            else {
+                                                var valid1 = true;
+                                            }
+                                            if (valid1) {
+                                                if (data.scale !== undefined) {
+                                                    const _errs41 = errors;
+                                                    if (!(validate11(data.scale, { instancePath: instancePath + "/scale", parentData: data, parentDataProperty: "scale", rootData }))) {
+                                                        vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);
+                                                        errors = vErrors.length;
+                                                    }
+                                                    var valid1 = _errs41 === errors;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                }
+                                                if (valid1) {
+                                                    if (data.borderRadius !== undefined) {
+                                                        let data11 = data.borderRadius;
+                                                        const _errs43 = errors;
+                                                        const _errs44 = errors;
+                                                        let valid15 = false;
+                                                        const _errs45 = errors;
+                                                        const _errs46 = errors;
+                                                        if (errors === _errs46) {
+                                                            if ((typeof data11 == "number") && (isFinite(data11))) {
+                                                                if (data11 > 50 || isNaN(data11)) {
+                                                                    const err30 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/maximum", keyword: "maximum", params: { comparison: "<=", limit: 50 }, message: "must be <= 50" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err30];
                                                                     }
                                                                     else {
-                                                                        const err51 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/color/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err51];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err51);
-                                                                        }
-                                                                        errors++;
+                                                                        vErrors.push(err30);
                                                                     }
+                                                                    errors++;
                                                                 }
-                                                                var _valid6 = _errs78 === errors;
-                                                                if (_valid6) {
-                                                                    valid26 = true;
-                                                                    passing6 = 0;
-                                                                }
-                                                                const _errs81 = errors;
-                                                                if (errors === _errs81) {
-                                                                    if (Array.isArray(data18)) {
-                                                                        if (data18.length > 128) {
-                                                                            const err52 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err52];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err52);
-                                                                            }
-                                                                            errors++;
-                                                                        }
-                                                                        else {
-                                                                            var valid28 = true;
-                                                                            const len6 = data18.length;
-                                                                            for (let i6 = 0; i6 < len6; i6++) {
-                                                                                let data19 = data18[i6];
-                                                                                const _errs83 = errors;
-                                                                                const _errs84 = errors;
-                                                                                if (errors === _errs84) {
-                                                                                    if (typeof data19 === "string") {
-                                                                                        if (!pattern15.test(data19)) {
-                                                                                            const err53 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i6, schemaPath: "#/definitions/color/pattern", keyword: "pattern", params: { pattern: "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, message: "must match pattern \"" + "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" + "\"" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err53];
-                                                                                            }
-                                                                                            else {
-                                                                                                vErrors.push(err53);
-                                                                                            }
-                                                                                            errors++;
-                                                                                        }
-                                                                                    }
-                                                                                    else {
-                                                                                        const err54 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i6, schemaPath: "#/definitions/color/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                                        if (vErrors === null) {
-                                                                                            vErrors = [err54];
-                                                                                        }
-                                                                                        else {
-                                                                                            vErrors.push(err54);
-                                                                                        }
-                                                                                        errors++;
-                                                                                    }
-                                                                                }
-                                                                                var valid28 = _errs83 === errors;
-                                                                                if (!valid28) {
-                                                                                    break;
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                    else {
-                                                                        const err55 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                else {
+                                                                    if (data11 < 0 || isNaN(data11)) {
+                                                                        const err31 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
                                                                         if (vErrors === null) {
-                                                                            vErrors = [err55];
+                                                                            vErrors = [err31];
                                                                         }
                                                                         else {
-                                                                            vErrors.push(err55);
+                                                                            vErrors.push(err31);
                                                                         }
                                                                         errors++;
                                                                     }
                                                                 }
-                                                                var _valid6 = _errs81 === errors;
-                                                                if (_valid6 && valid26) {
-                                                                    valid26 = false;
-                                                                    passing6 = [passing6, 1];
-                                                                }
-                                                                else {
-                                                                    if (_valid6) {
-                                                                        valid26 = true;
-                                                                        passing6 = 1;
-                                                                    }
-                                                                }
-                                                                if (!valid26) {
-                                                                    const err56 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing6 }, message: "must match exactly one schema in oneOf" };
-                                                                    if (vErrors === null) {
-                                                                        vErrors = [err56];
-                                                                    }
-                                                                    else {
-                                                                        vErrors.push(err56);
-                                                                    }
-                                                                    errors++;
-                                                                    validate10.errors = vErrors;
-                                                                    return false;
+                                                            }
+                                                            else {
+                                                                const err32 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/definitions/borderRadius/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                if (vErrors === null) {
+                                                                    vErrors = [err32];
                                                                 }
                                                                 else {
-                                                                    errors = _errs77;
-                                                                    if (vErrors !== null) {
-                                                                        if (_errs77) {
-                                                                            vErrors.length = _errs77;
-                                                                        }
-                                                                        else {
-                                                                            vErrors = null;
-                                                                        }
-                                                                    }
-                                                                }
-                                                                var valid21 = _errs76 === errors;
-                                                                if (!valid21) {
-                                                                    break;
+                                                                    vErrors.push(err32);
                                                                 }
+                                                                errors++;
                                                             }
                                                         }
-                                                        if (valid21) {
-                                                            var valid21 = true;
-                                                            for (const key6 in data) {
-                                                                if (pattern3.test(key6)) {
-                                                                    let data20 = data[key6];
-                                                                    const _errs86 = errors;
-                                                                    const _errs87 = errors;
-                                                                    let valid30 = false;
-                                                                    let passing7 = null;
-                                                                    const _errs88 = errors;
-                                                                    if (typeof data20 !== "string") {
-                                                                        const err57 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFill/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err57];
-                                                                        }
-                                                                        else {
-                                                                            vErrors.push(err57);
-                                                                        }
-                                                                        errors++;
-                                                                    }
-                                                                    if (!(((data20 === "solid") || (data20 === "linear")) || (data20 === "radial"))) {
-                                                                        const err58 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFill/enum", keyword: "enum", params: { allowedValues: schema24.enum }, message: "must be equal to one of the allowed values" };
+                                                        var _valid3 = _errs45 === errors;
+                                                        valid15 = valid15 || _valid3;
+                                                        if (!valid15) {
+                                                            const _errs48 = errors;
+                                                            if (errors === _errs48) {
+                                                                if (Array.isArray(data11)) {
+                                                                    if (data11.length > 2) {
+                                                                        const err33 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
                                                                         if (vErrors === null) {
-                                                                            vErrors = [err58];
+                                                                            vErrors = [err33];
                                                                         }
                                                                         else {
-                                                                            vErrors.push(err58);
+                                                                            vErrors.push(err33);
                                                                         }
                                                                         errors++;
                                                                     }
-                                                                    var _valid7 = _errs88 === errors;
-                                                                    if (_valid7) {
-                                                                        valid30 = true;
-                                                                        passing7 = 0;
-                                                                    }
-                                                                    const _errs91 = errors;
-                                                                    if (errors === _errs91) {
-                                                                        if (Array.isArray(data20)) {
-                                                                            if (data20.length > 128) {
-                                                                                const err59 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
-                                                                                if (vErrors === null) {
-                                                                                    vErrors = [err59];
-                                                                                }
-                                                                                else {
-                                                                                    vErrors.push(err59);
-                                                                                }
-                                                                                errors++;
+                                                                    else {
+                                                                        if (data11.length < 0) {
+                                                                            const err34 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err34];
                                                                             }
                                                                             else {
-                                                                                var valid32 = true;
-                                                                                const len7 = data20.length;
-                                                                                for (let i7 = 0; i7 < len7; i7++) {
-                                                                                    let data21 = data20[i7];
-                                                                                    const _errs93 = errors;
-                                                                                    if (typeof data21 !== "string") {
-                                                                                        const err60 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i7, schemaPath: "#/definitions/colorFill/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                                                                                        if (vErrors === null) {
-                                                                                            vErrors = [err60];
+                                                                                vErrors.push(err34);
+                                                                            }
+                                                                            errors++;
+                                                                        }
+                                                                        else {
+                                                                            var valid17 = true;
+                                                                            const len3 = data11.length;
+                                                                            for (let i3 = 0; i3 < len3; i3++) {
+                                                                                let data12 = data11[i3];
+                                                                                const _errs50 = errors;
+                                                                                const _errs51 = errors;
+                                                                                if (errors === _errs51) {
+                                                                                    if ((typeof data12 == "number") && (isFinite(data12))) {
+                                                                                        if (data12 > 50 || isNaN(data12)) {
+                                                                                            const err35 = { instancePath: instancePath + "/borderRadius/" + i3, schemaPath: "#/definitions/borderRadius/maximum", keyword: "maximum", params: { comparison: "<=", limit: 50 }, message: "must be <= 50" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err35];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err35);
+                                                                                            }
+                                                                                            errors++;
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err60);
+                                                                                            if (data12 < 0 || isNaN(data12)) {
+                                                                                                const err36 = { instancePath: instancePath + "/borderRadius/" + i3, schemaPath: "#/definitions/borderRadius/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                                                                                if (vErrors === null) {
+                                                                                                    vErrors = [err36];
+                                                                                                }
+                                                                                                else {
+                                                                                                    vErrors.push(err36);
+                                                                                                }
+                                                                                                errors++;
+                                                                                            }
                                                                                         }
-                                                                                        errors++;
                                                                                     }
-                                                                                    if (!(((data21 === "solid") || (data21 === "linear")) || (data21 === "radial"))) {
-                                                                                        const err61 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i7, schemaPath: "#/definitions/colorFill/enum", keyword: "enum", params: { allowedValues: schema24.enum }, message: "must be equal to one of the allowed values" };
+                                                                                    else {
+                                                                                        const err37 = { instancePath: instancePath + "/borderRadius/" + i3, schemaPath: "#/definitions/borderRadius/type", keyword: "type", params: { type: "number" }, message: "must be number" };
                                                                                         if (vErrors === null) {
-                                                                                            vErrors = [err61];
+                                                                                            vErrors = [err37];
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err61);
+                                                                                            vErrors.push(err37);
                                                                                         }
                                                                                         errors++;
                                                                                     }
-                                                                                    var valid32 = _errs93 === errors;
-                                                                                    if (!valid32) {
-                                                                                        break;
-                                                                                    }
+                                                                                }
+                                                                                var valid17 = _errs50 === errors;
+                                                                                if (!valid17) {
+                                                                                    break;
                                                                                 }
                                                                             }
                                                                         }
-                                                                        else {
-                                                                            const err62 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err62];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err62);
-                                                                            }
-                                                                            errors++;
-                                                                        }
                                                                     }
-                                                                    var _valid7 = _errs91 === errors;
-                                                                    if (_valid7 && valid30) {
-                                                                        valid30 = false;
-                                                                        passing7 = [passing7, 1];
+                                                                }
+                                                                else {
+                                                                    const err38 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err38];
                                                                     }
                                                                     else {
-                                                                        if (_valid7) {
-                                                                            valid30 = true;
-                                                                            passing7 = 1;
-                                                                        }
+                                                                        vErrors.push(err38);
                                                                     }
-                                                                    if (!valid30) {
-                                                                        const err63 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing7 }, message: "must match exactly one schema in oneOf" };
-                                                                        if (vErrors === null) {
-                                                                            vErrors = [err63];
+                                                                    errors++;
+                                                                }
+                                                            }
+                                                            var _valid3 = _errs48 === errors;
+                                                            valid15 = valid15 || _valid3;
+                                                        }
+                                                        if (!valid15) {
+                                                            const err39 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err39];
+                                                            }
+                                                            else {
+                                                                vErrors.push(err39);
+                                                            }
+                                                            errors++;
+                                                            validate10.errors = vErrors;
+                                                            return false;
+                                                        }
+                                                        else {
+                                                            errors = _errs44;
+                                                            if (vErrors !== null) {
+                                                                if (_errs44) {
+                                                                    vErrors.length = _errs44;
+                                                                }
+                                                                else {
+                                                                    vErrors = null;
+                                                                }
+                                                            }
+                                                        }
+                                                        var valid1 = _errs43 === errors;
+                                                    }
+                                                    else {
+                                                        var valid1 = true;
+                                                    }
+                                                    if (valid1) {
+                                                        var valid19 = true;
+                                                        for (const key2 in data) {
+                                                            if (pattern0.test(key2)) {
+                                                                let data13 = data[key2];
+                                                                const _errs53 = errors;
+                                                                if (errors === _errs53) {
+                                                                    if ((typeof data13 == "number") && (isFinite(data13))) {
+                                                                        if (data13 > 100 || isNaN(data13)) {
+                                                                            validate10.errors = [{ instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" }];
+                                                                            return false;
                                                                         }
                                                                         else {
-                                                                            vErrors.push(err63);
-                                                                        }
-                                                                        errors++;
-                                                                        validate10.errors = vErrors;
-                                                                        return false;
-                                                                    }
-                                                                    else {
-                                                                        errors = _errs87;
-                                                                        if (vErrors !== null) {
-                                                                            if (_errs87) {
-                                                                                vErrors.length = _errs87;
-                                                                            }
-                                                                            else {
-                                                                                vErrors = null;
+                                                                            if (data13 < 0 || isNaN(data13)) {
+                                                                                validate10.errors = [{ instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" }];
+                                                                                return false;
                                                                             }
                                                                         }
                                                                     }
-                                                                    var valid21 = _errs86 === errors;
-                                                                    if (!valid21) {
-                                                                        break;
+                                                                    else {
+                                                                        validate10.errors = [{ instancePath: instancePath + "/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Probability%24/type", keyword: "type", params: { type: "number" }, message: "must be number" }];
+                                                                        return false;
                                                                     }
                                                                 }
+                                                                var valid19 = _errs53 === errors;
+                                                                if (!valid19) {
+                                                                    break;
+                                                                }
                                                             }
-                                                            if (valid21) {
-                                                                var valid21 = true;
-                                                                for (const key7 in data) {
-                                                                    if (pattern4.test(key7)) {
-                                                                        let data22 = data[key7];
-                                                                        const _errs96 = errors;
-                                                                        const _errs97 = errors;
-                                                                        let valid34 = false;
-                                                                        let passing8 = null;
-                                                                        const _errs98 = errors;
-                                                                        const _errs99 = errors;
-                                                                        if (!(((typeof data22 == "number") && (!(data22 % 1) && !isNaN(data22))) && (isFinite(data22)))) {
-                                                                            const err64 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err64];
+                                                        }
+                                                        if (valid19) {
+                                                            var valid19 = true;
+                                                            for (const key3 in data) {
+                                                                if (pattern1.test(key3)) {
+                                                                    let data14 = data[key3];
+                                                                    const _errs55 = errors;
+                                                                    const _errs56 = errors;
+                                                                    let valid20 = false;
+                                                                    const _errs57 = errors;
+                                                                    const _errs58 = errors;
+                                                                    if (errors === _errs58) {
+                                                                        if (typeof data14 === "string") {
+                                                                            if (func2(data14) > 64) {
+                                                                                const err40 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err40];
+                                                                                }
+                                                                                else {
+                                                                                    vErrors.push(err40);
+                                                                                }
+                                                                                errors++;
                                                                             }
                                                                             else {
-                                                                                vErrors.push(err64);
-                                                                            }
-                                                                            errors++;
-                                                                        }
-                                                                        if (errors === _errs99) {
-                                                                            if ((typeof data22 == "number") && (isFinite(data22))) {
-                                                                                if (data22 < 2 || isNaN(data22)) {
-                                                                                    const err65 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 2 }, message: "must be >= 2" };
+                                                                                if (!pattern13.test(data14)) {
+                                                                                    const err41 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/pattern", keyword: "pattern", params: { pattern: "^[a-z][a-zA-Z0-9]*$" }, message: "must match pattern \"" + "^[a-z][a-zA-Z0-9]*$" + "\"" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err65];
+                                                                                        vErrors = [err41];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err65);
+                                                                                        vErrors.push(err41);
                                                                                     }
                                                                                     errors++;
                                                                                 }
                                                                             }
                                                                         }
-                                                                        var _valid8 = _errs98 === errors;
-                                                                        if (_valid8) {
-                                                                            valid34 = true;
-                                                                            passing8 = 0;
+                                                                        else {
+                                                                            const err42 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err42];
+                                                                            }
+                                                                            else {
+                                                                                vErrors.push(err42);
+                                                                            }
+                                                                            errors++;
                                                                         }
-                                                                        const _errs101 = errors;
-                                                                        if (errors === _errs101) {
-                                                                            if (Array.isArray(data22)) {
-                                                                                if (data22.length > 2) {
-                                                                                    const err66 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                                                                    }
+                                                                    var _valid4 = _errs57 === errors;
+                                                                    valid20 = valid20 || _valid4;
+                                                                    if (!valid20) {
+                                                                        const _errs60 = errors;
+                                                                        if (errors === _errs60) {
+                                                                            if (Array.isArray(data14)) {
+                                                                                if (data14.length > 128) {
+                                                                                    const err43 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err66];
+                                                                                        vErrors = [err43];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err66);
+                                                                                        vErrors.push(err43);
                                                                                     }
                                                                                     errors++;
                                                                                 }
                                                                                 else {
-                                                                                    var valid36 = true;
-                                                                                    const len8 = data22.length;
-                                                                                    for (let i8 = 0; i8 < len8; i8++) {
-                                                                                        let data23 = data22[i8];
-                                                                                        const _errs103 = errors;
-                                                                                        const _errs104 = errors;
-                                                                                        if (!(((typeof data23 == "number") && (!(data23 % 1) && !isNaN(data23))) && (isFinite(data23)))) {
-                                                                                            const err67 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i8, schemaPath: "#/definitions/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err67];
-                                                                                            }
-                                                                                            else {
-                                                                                                vErrors.push(err67);
-                                                                                            }
-                                                                                            errors++;
+                                                                                    if (data14.length < 0) {
+                                                                                        const err44 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err44];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err44);
                                                                                         }
-                                                                                        if (errors === _errs104) {
-                                                                                            if ((typeof data23 == "number") && (isFinite(data23))) {
-                                                                                                if (data23 < 2 || isNaN(data23)) {
-                                                                                                    const err68 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i8, schemaPath: "#/definitions/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 2 }, message: "must be >= 2" };
+                                                                                        errors++;
+                                                                                    }
+                                                                                    else {
+                                                                                        var valid22 = true;
+                                                                                        const len4 = data14.length;
+                                                                                        for (let i4 = 0; i4 < len4; i4++) {
+                                                                                            let data15 = data14[i4];
+                                                                                            const _errs62 = errors;
+                                                                                            const _errs63 = errors;
+                                                                                            if (errors === _errs63) {
+                                                                                                if (typeof data15 === "string") {
+                                                                                                    if (func2(data15) > 64) {
+                                                                                                        const err45 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i4, schemaPath: "#/definitions/variantName/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters" };
+                                                                                                        if (vErrors === null) {
+                                                                                                            vErrors = [err45];
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            vErrors.push(err45);
+                                                                                                        }
+                                                                                                        errors++;
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        if (!pattern13.test(data15)) {
+                                                                                                            const err46 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i4, schemaPath: "#/definitions/variantName/pattern", keyword: "pattern", params: { pattern: "^[a-z][a-zA-Z0-9]*$" }, message: "must match pattern \"" + "^[a-z][a-zA-Z0-9]*$" + "\"" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err46];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err46);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    const err47 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i4, schemaPath: "#/definitions/variantName/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                                                                     if (vErrors === null) {
-                                                                                                        vErrors = [err68];
+                                                                                                        vErrors = [err47];
                                                                                                     }
                                                                                                     else {
-                                                                                                        vErrors.push(err68);
+                                                                                                        vErrors.push(err47);
                                                                                                     }
                                                                                                     errors++;
                                                                                                 }
                                                                                             }
-                                                                                        }
-                                                                                        var valid36 = _errs103 === errors;
-                                                                                        if (!valid36) {
-                                                                                            break;
+                                                                                            var valid22 = _errs62 === errors;
+                                                                                            if (!valid22) {
+                                                                                                break;
+                                                                                            }
                                                                                         }
                                                                                     }
                                                                                 }
                                                                             }
                                                                             else {
-                                                                                const err69 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                const err48 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                 if (vErrors === null) {
-                                                                                    vErrors = [err69];
+                                                                                    vErrors = [err48];
                                                                                 }
                                                                                 else {
-                                                                                    vErrors.push(err69);
+                                                                                    vErrors.push(err48);
                                                                                 }
                                                                                 errors++;
                                                                             }
                                                                         }
-                                                                        var _valid8 = _errs101 === errors;
-                                                                        if (_valid8 && valid34) {
-                                                                            valid34 = false;
-                                                                            passing8 = [passing8, 1];
-                                                                        }
-                                                                        else {
-                                                                            if (_valid8) {
-                                                                                valid34 = true;
-                                                                                passing8 = 1;
-                                                                            }
-                                                                        }
-                                                                        if (!valid34) {
-                                                                            const err70 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing8 }, message: "must match exactly one schema in oneOf" };
-                                                                            if (vErrors === null) {
-                                                                                vErrors = [err70];
-                                                                            }
-                                                                            else {
-                                                                                vErrors.push(err70);
-                                                                            }
-                                                                            errors++;
-                                                                            validate10.errors = vErrors;
-                                                                            return false;
-                                                                        }
-                                                                        else {
-                                                                            errors = _errs97;
-                                                                            if (vErrors !== null) {
-                                                                                if (_errs97) {
-                                                                                    vErrors.length = _errs97;
-                                                                                }
-                                                                                else {
-                                                                                    vErrors = null;
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                        var valid21 = _errs96 === errors;
-                                                                        if (!valid21) {
-                                                                            break;
-                                                                        }
-                                                                    }
-                                                                }
-                                                                if (valid21) {
-                                                                    var valid21 = true;
-                                                                    for (const key8 in data) {
-                                                                        if (pattern5.test(key8)) {
-                                                                            let data24 = data[key8];
-                                                                            const _errs106 = errors;
-                                                                            const _errs107 = errors;
-                                                                            let valid38 = false;
-                                                                            let passing9 = null;
-                                                                            const _errs108 = errors;
-                                                                            const _errs109 = errors;
-                                                                            if (errors === _errs109) {
-                                                                                if ((typeof data24 == "number") && (isFinite(data24))) {
-                                                                                    if (data24 > 360 || isNaN(data24)) {
-                                                                                        const err71 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+                                                                        var _valid4 = _errs60 === errors;
+                                                                        valid20 = valid20 || _valid4;
+                                                                        if (!valid20) {
+                                                                            const _errs65 = errors;
+                                                                            if (errors === _errs65) {
+                                                                                if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
+                                                                                    if (Object.keys(data14).length > 512) {
+                                                                                        const err49 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/maxProperties", keyword: "maxProperties", params: { limit: 512 }, message: "must NOT have more than 512 properties" };
                                                                                         if (vErrors === null) {
-                                                                                            vErrors = [err71];
+                                                                                            vErrors = [err49];
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err71);
+                                                                                            vErrors.push(err49);
                                                                                         }
                                                                                         errors++;
                                                                                     }
                                                                                     else {
-                                                                                        if (data24 < -360 || isNaN(data24)) {
-                                                                                            const err72 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                        if (Object.keys(data14).length < 1) {
+                                                                                            const err50 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/minProperties", keyword: "minProperties", params: { limit: 1 }, message: "must NOT have fewer than 1 properties" };
                                                                                             if (vErrors === null) {
-                                                                                                vErrors = [err72];
+                                                                                                vErrors = [err50];
                                                                                             }
                                                                                             else {
-                                                                                                vErrors.push(err72);
+                                                                                                vErrors.push(err50);
                                                                                             }
                                                                                             errors++;
                                                                                         }
+                                                                                        else {
+                                                                                            for (const key4 in data14) {
+                                                                                                const _errs67 = errors;
+                                                                                                const _errs68 = errors;
+                                                                                                if (errors === _errs68) {
+                                                                                                    if (typeof key4 === "string") {
+                                                                                                        if (func2(key4) > 64) {
+                                                                                                            const err51 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/maxLength", keyword: "maxLength", params: { limit: 64 }, message: "must NOT have more than 64 characters", propertyName: key4 };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err51];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err51);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            if (!pattern13.test(key4)) {
+                                                                                                                const err52 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/pattern", keyword: "pattern", params: { pattern: "^[a-z][a-zA-Z0-9]*$" }, message: "must match pattern \"" + "^[a-z][a-zA-Z0-9]*$" + "\"", propertyName: key4 };
+                                                                                                                if (vErrors === null) {
+                                                                                                                    vErrors = [err52];
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    vErrors.push(err52);
+                                                                                                                }
+                                                                                                                errors++;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        const err53 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/variantName/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key4 };
+                                                                                                        if (vErrors === null) {
+                                                                                                            vErrors = [err53];
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            vErrors.push(err53);
+                                                                                                        }
+                                                                                                        errors++;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid24 = _errs67 === errors;
+                                                                                                if (!valid24) {
+                                                                                                    const err54 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/propertyNames", keyword: "propertyNames", params: { propertyName: key4 }, message: "property name must be valid" };
+                                                                                                    if (vErrors === null) {
+                                                                                                        vErrors = [err54];
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        vErrors.push(err54);
+                                                                                                    }
+                                                                                                    errors++;
+                                                                                                    break;
+                                                                                                }
+                                                                                            }
+                                                                                            if (valid24) {
+                                                                                                for (const key5 in data14) {
+                                                                                                    let data16 = data14[key5];
+                                                                                                    const _errs71 = errors;
+                                                                                                    if (errors === _errs71) {
+                                                                                                        if ((typeof data16 == "number") && (isFinite(data16))) {
+                                                                                                            if (data16 < 0 || isNaN(data16)) {
+                                                                                                                const err55 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/additionalProperties/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                                                                                                if (vErrors === null) {
+                                                                                                                    vErrors = [err55];
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    vErrors.push(err55);
+                                                                                                                }
+                                                                                                                errors++;
+                                                                                                            }
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            const err56 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/additionalProperties/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err56];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err56);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    var valid26 = _errs71 === errors;
+                                                                                                    if (!valid26) {
+                                                                                                        break;
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                        }
                                                                                     }
                                                                                 }
                                                                                 else {
-                                                                                    const err73 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                    const err57 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf/2/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err57];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err57);
+                                                                                    }
+                                                                                    errors++;
+                                                                                }
+                                                                            }
+                                                                            var _valid4 = _errs65 === errors;
+                                                                            valid20 = valid20 || _valid4;
+                                                                        }
+                                                                    }
+                                                                    if (!valid20) {
+                                                                        const err58 = { instancePath: instancePath + "/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Variant%24/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err58];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err58);
+                                                                        }
+                                                                        errors++;
+                                                                        validate10.errors = vErrors;
+                                                                        return false;
+                                                                    }
+                                                                    else {
+                                                                        errors = _errs56;
+                                                                        if (vErrors !== null) {
+                                                                            if (_errs56) {
+                                                                                vErrors.length = _errs56;
+                                                                            }
+                                                                            else {
+                                                                                vErrors = null;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    var valid19 = _errs55 === errors;
+                                                                    if (!valid19) {
+                                                                        break;
+                                                                    }
+                                                                }
+                                                            }
+                                                            if (valid19) {
+                                                                var valid19 = true;
+                                                                for (const key6 in data) {
+                                                                    if (pattern2.test(key6)) {
+                                                                        let data17 = data[key6];
+                                                                        const _errs73 = errors;
+                                                                        const _errs74 = errors;
+                                                                        let valid27 = false;
+                                                                        const _errs75 = errors;
+                                                                        const _errs76 = errors;
+                                                                        if (errors === _errs76) {
+                                                                            if (typeof data17 === "string") {
+                                                                                if (!pattern17.test(data17)) {
+                                                                                    const err59 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/color/pattern", keyword: "pattern", params: { pattern: "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, message: "must match pattern \"" + "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" + "\"" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err73];
+                                                                                        vErrors = [err59];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err73);
+                                                                                        vErrors.push(err59);
                                                                                     }
                                                                                     errors++;
                                                                                 }
                                                                             }
-                                                                            var _valid9 = _errs108 === errors;
-                                                                            if (_valid9) {
-                                                                                valid38 = true;
-                                                                                passing9 = 0;
+                                                                            else {
+                                                                                const err60 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/color/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err60];
+                                                                                }
+                                                                                else {
+                                                                                    vErrors.push(err60);
+                                                                                }
+                                                                                errors++;
                                                                             }
-                                                                            const _errs111 = errors;
-                                                                            if (errors === _errs111) {
-                                                                                if (Array.isArray(data24)) {
-                                                                                    if (data24.length > 2) {
-                                                                                        const err74 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorAngle%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+                                                                        }
+                                                                        var _valid5 = _errs75 === errors;
+                                                                        valid27 = valid27 || _valid5;
+                                                                        if (!valid27) {
+                                                                            const _errs78 = errors;
+                                                                            if (errors === _errs78) {
+                                                                                if (Array.isArray(data17)) {
+                                                                                    if (data17.length > 128) {
+                                                                                        const err61 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                                                         if (vErrors === null) {
-                                                                                            vErrors = [err74];
+                                                                                            vErrors = [err61];
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err74);
+                                                                                            vErrors.push(err61);
                                                                                         }
                                                                                         errors++;
                                                                                     }
                                                                                     else {
-                                                                                        var valid40 = true;
-                                                                                        const len9 = data24.length;
-                                                                                        for (let i9 = 0; i9 < len9; i9++) {
-                                                                                            let data25 = data24[i9];
-                                                                                            const _errs113 = errors;
-                                                                                            const _errs114 = errors;
-                                                                                            if (errors === _errs114) {
-                                                                                                if ((typeof data25 == "number") && (isFinite(data25))) {
-                                                                                                    if (data25 > 360 || isNaN(data25)) {
-                                                                                                        const err75 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i9, schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
-                                                                                                        if (vErrors === null) {
-                                                                                                            vErrors = [err75];
-                                                                                                        }
-                                                                                                        else {
-                                                                                                            vErrors.push(err75);
-                                                                                                        }
-                                                                                                        errors++;
-                                                                                                    }
-                                                                                                    else {
-                                                                                                        if (data25 < -360 || isNaN(data25)) {
-                                                                                                            const err76 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i9, schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                        if (data17.length < 0) {
+                                                                                            const err62 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err62];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err62);
+                                                                                            }
+                                                                                            errors++;
+                                                                                        }
+                                                                                        else {
+                                                                                            var valid29 = true;
+                                                                                            const len5 = data17.length;
+                                                                                            for (let i5 = 0; i5 < len5; i5++) {
+                                                                                                let data18 = data17[i5];
+                                                                                                const _errs80 = errors;
+                                                                                                const _errs81 = errors;
+                                                                                                if (errors === _errs81) {
+                                                                                                    if (typeof data18 === "string") {
+                                                                                                        if (!pattern17.test(data18)) {
+                                                                                                            const err63 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i5, schemaPath: "#/definitions/color/pattern", keyword: "pattern", params: { pattern: "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" }, message: "must match pattern \"" + "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" + "\"" };
                                                                                                             if (vErrors === null) {
-                                                                                                                vErrors = [err76];
+                                                                                                                vErrors = [err63];
                                                                                                             }
                                                                                                             else {
-                                                                                                                vErrors.push(err76);
+                                                                                                                vErrors.push(err63);
                                                                                                             }
                                                                                                             errors++;
                                                                                                         }
                                                                                                     }
-                                                                                                }
-                                                                                                else {
-                                                                                                    const err77 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i9, schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                                    if (vErrors === null) {
-                                                                                                        vErrors = [err77];
-                                                                                                    }
                                                                                                     else {
-                                                                                                        vErrors.push(err77);
+                                                                                                        const err64 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i5, schemaPath: "#/definitions/color/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                                        if (vErrors === null) {
+                                                                                                            vErrors = [err64];
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            vErrors.push(err64);
+                                                                                                        }
+                                                                                                        errors++;
                                                                                                     }
-                                                                                                    errors++;
                                                                                                 }
-                                                                                            }
-                                                                                            var valid40 = _errs113 === errors;
-                                                                                            if (!valid40) {
-                                                                                                break;
+                                                                                                var valid29 = _errs80 === errors;
+                                                                                                if (!valid29) {
+                                                                                                    break;
+                                                                                                }
                                                                                             }
                                                                                         }
                                                                                     }
                                                                                 }
                                                                                 else {
-                                                                                    const err78 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorAngle%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                    const err65 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err78];
+                                                                                        vErrors = [err65];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err78);
+                                                                                        vErrors.push(err65);
                                                                                     }
                                                                                     errors++;
                                                                                 }
                                                                             }
-                                                                            var _valid9 = _errs111 === errors;
-                                                                            if (_valid9 && valid38) {
-                                                                                valid38 = false;
-                                                                                passing9 = [passing9, 1];
+                                                                            var _valid5 = _errs78 === errors;
+                                                                            valid27 = valid27 || _valid5;
+                                                                        }
+                                                                        if (!valid27) {
+                                                                            const err66 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*Color%24/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err66];
                                                                             }
                                                                             else {
-                                                                                if (_valid9) {
-                                                                                    valid38 = true;
-                                                                                    passing9 = 1;
+                                                                                vErrors.push(err66);
+                                                                            }
+                                                                            errors++;
+                                                                            validate10.errors = vErrors;
+                                                                            return false;
+                                                                        }
+                                                                        else {
+                                                                            errors = _errs74;
+                                                                            if (vErrors !== null) {
+                                                                                if (_errs74) {
+                                                                                    vErrors.length = _errs74;
+                                                                                }
+                                                                                else {
+                                                                                    vErrors = null;
                                                                                 }
                                                                             }
-                                                                            if (!valid38) {
-                                                                                const err79 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorAngle%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing9 }, message: "must match exactly one schema in oneOf" };
+                                                                        }
+                                                                        var valid19 = _errs73 === errors;
+                                                                        if (!valid19) {
+                                                                            break;
+                                                                        }
+                                                                    }
+                                                                }
+                                                                if (valid19) {
+                                                                    var valid19 = true;
+                                                                    for (const key7 in data) {
+                                                                        if (pattern3.test(key7)) {
+                                                                            let data19 = data[key7];
+                                                                            const _errs83 = errors;
+                                                                            const _errs84 = errors;
+                                                                            let valid31 = false;
+                                                                            const _errs85 = errors;
+                                                                            if (typeof data19 !== "string") {
+                                                                                const err67 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFill/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                                                                                 if (vErrors === null) {
-                                                                                    vErrors = [err79];
+                                                                                    vErrors = [err67];
                                                                                 }
                                                                                 else {
-                                                                                    vErrors.push(err79);
+                                                                                    vErrors.push(err67);
                                                                                 }
                                                                                 errors++;
-                                                                                validate10.errors = vErrors;
-                                                                                return false;
                                                                             }
-                                                                            else {
-                                                                                errors = _errs107;
-                                                                                if (vErrors !== null) {
-                                                                                    if (_errs107) {
-                                                                                        vErrors.length = _errs107;
-                                                                                    }
-                                                                                    else {
-                                                                                        vErrors = null;
-                                                                                    }
+                                                                            if (!(((data19 === "solid") || (data19 === "linear")) || (data19 === "radial"))) {
+                                                                                const err68 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFill/enum", keyword: "enum", params: { allowedValues: schema28.enum }, message: "must be equal to one of the allowed values" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err68];
                                                                                 }
+                                                                                else {
+                                                                                    vErrors.push(err68);
+                                                                                }
+                                                                                errors++;
                                                                             }
-                                                                            var valid21 = _errs106 === errors;
-                                                                            if (!valid21) {
-                                                                                break;
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                    if (valid21) {
-                                                                        var valid21 = true;
-                                                                        for (const key9 in data) {
-                                                                            if (pattern6.test(key9)) {
-                                                                                let data26 = data[key9];
-                                                                                const _errs116 = errors;
-                                                                                const _errs117 = errors;
-                                                                                let valid42 = false;
-                                                                                let passing10 = null;
-                                                                                const _errs118 = errors;
-                                                                                const _errs119 = errors;
-                                                                                if (errors === _errs119) {
-                                                                                    if ((typeof data26 == "number") && (isFinite(data26))) {
-                                                                                        if (data26 > 360 || isNaN(data26)) {
-                                                                                            const err80 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+                                                                            var _valid6 = _errs85 === errors;
+                                                                            valid31 = valid31 || _valid6;
+                                                                            if (!valid31) {
+                                                                                const _errs88 = errors;
+                                                                                if (errors === _errs88) {
+                                                                                    if (Array.isArray(data19)) {
+                                                                                        if (data19.length > 128) {
+                                                                                            const err69 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 128 }, message: "must NOT have more than 128 items" };
                                                                                             if (vErrors === null) {
-                                                                                                vErrors = [err80];
+                                                                                                vErrors = [err69];
                                                                                             }
                                                                                             else {
-                                                                                                vErrors.push(err80);
+                                                                                                vErrors.push(err69);
                                                                                             }
                                                                                             errors++;
                                                                                         }
                                                                                         else {
-                                                                                            if (data26 < -360 || isNaN(data26)) {
-                                                                                                const err81 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                            if (data19.length < 0) {
+                                                                                                const err70 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
                                                                                                 if (vErrors === null) {
-                                                                                                    vErrors = [err81];
+                                                                                                    vErrors = [err70];
                                                                                                 }
                                                                                                 else {
-                                                                                                    vErrors.push(err81);
+                                                                                                    vErrors.push(err70);
                                                                                                 }
                                                                                                 errors++;
                                                                                             }
-                                                                                        }
-                                                                                    }
-                                                                                    else {
-                                                                                        const err82 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                        if (vErrors === null) {
-                                                                                            vErrors = [err82];
-                                                                                        }
-                                                                                        else {
-                                                                                            vErrors.push(err82);
-                                                                                        }
-                                                                                        errors++;
-                                                                                    }
-                                                                                }
-                                                                                var _valid10 = _errs118 === errors;
-                                                                                if (_valid10) {
-                                                                                    valid42 = true;
-                                                                                    passing10 = 0;
-                                                                                }
-                                                                                const _errs121 = errors;
-                                                                                if (errors === _errs121) {
-                                                                                    if (Array.isArray(data26)) {
-                                                                                        if (data26.length > 2) {
-                                                                                            const err83 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(r%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*R)otate%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err83];
-                                                                                            }
                                                                                             else {
-                                                                                                vErrors.push(err83);
-                                                                                            }
-                                                                                            errors++;
-                                                                                        }
-                                                                                        else {
-                                                                                            var valid44 = true;
-                                                                                            const len10 = data26.length;
-                                                                                            for (let i10 = 0; i10 < len10; i10++) {
-                                                                                                let data27 = data26[i10];
-                                                                                                const _errs123 = errors;
-                                                                                                const _errs124 = errors;
-                                                                                                if (errors === _errs124) {
-                                                                                                    if ((typeof data27 == "number") && (isFinite(data27))) {
-                                                                                                        if (data27 > 360 || isNaN(data27)) {
-                                                                                                            const err84 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i10, schemaPath: "#/definitions/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
-                                                                                                            if (vErrors === null) {
-                                                                                                                vErrors = [err84];
-                                                                                                            }
-                                                                                                            else {
-                                                                                                                vErrors.push(err84);
-                                                                                                            }
-                                                                                                            errors++;
+                                                                                                var valid33 = true;
+                                                                                                const len6 = data19.length;
+                                                                                                for (let i6 = 0; i6 < len6; i6++) {
+                                                                                                    let data20 = data19[i6];
+                                                                                                    const _errs90 = errors;
+                                                                                                    if (typeof data20 !== "string") {
+                                                                                                        const err71 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i6, schemaPath: "#/definitions/colorFill/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                                        if (vErrors === null) {
+                                                                                                            vErrors = [err71];
                                                                                                         }
                                                                                                         else {
-                                                                                                            if (data27 < -360 || isNaN(data27)) {
-                                                                                                                const err85 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i10, schemaPath: "#/definitions/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
-                                                                                                                if (vErrors === null) {
-                                                                                                                    vErrors = [err85];
-                                                                                                                }
-                                                                                                                else {
-                                                                                                                    vErrors.push(err85);
-                                                                                                                }
-                                                                                                                errors++;
-                                                                                                            }
+                                                                                                            vErrors.push(err71);
                                                                                                         }
+                                                                                                        errors++;
                                                                                                     }
-                                                                                                    else {
-                                                                                                        const err86 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i10, schemaPath: "#/definitions/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                    if (!(((data20 === "solid") || (data20 === "linear")) || (data20 === "radial"))) {
+                                                                                                        const err72 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i6, schemaPath: "#/definitions/colorFill/enum", keyword: "enum", params: { allowedValues: schema28.enum }, message: "must be equal to one of the allowed values" };
                                                                                                         if (vErrors === null) {
-                                                                                                            vErrors = [err86];
+                                                                                                            vErrors = [err72];
                                                                                                         }
                                                                                                         else {
-                                                                                                            vErrors.push(err86);
+                                                                                                            vErrors.push(err72);
                                                                                                         }
                                                                                                         errors++;
                                                                                                     }
-                                                                                                }
-                                                                                                var valid44 = _errs123 === errors;
-                                                                                                if (!valid44) {
-                                                                                                    break;
+                                                                                                    var valid33 = _errs90 === errors;
+                                                                                                    if (!valid33) {
+                                                                                                        break;
+                                                                                                    }
                                                                                                 }
                                                                                             }
                                                                                         }
                                                                                     }
                                                                                     else {
-                                                                                        const err87 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(r%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*R)otate%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                        const err73 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                         if (vErrors === null) {
-                                                                                            vErrors = [err87];
+                                                                                            vErrors = [err73];
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err87);
+                                                                                            vErrors.push(err73);
                                                                                         }
                                                                                         errors++;
                                                                                     }
                                                                                 }
-                                                                                var _valid10 = _errs121 === errors;
-                                                                                if (_valid10 && valid42) {
-                                                                                    valid42 = false;
-                                                                                    passing10 = [passing10, 1];
+                                                                                var _valid6 = _errs88 === errors;
+                                                                                valid31 = valid31 || _valid6;
+                                                                            }
+                                                                            if (!valid31) {
+                                                                                const err74 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFill%24/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err74];
                                                                                 }
                                                                                 else {
-                                                                                    if (_valid10) {
-                                                                                        valid42 = true;
-                                                                                        passing10 = 1;
+                                                                                    vErrors.push(err74);
+                                                                                }
+                                                                                errors++;
+                                                                                validate10.errors = vErrors;
+                                                                                return false;
+                                                                            }
+                                                                            else {
+                                                                                errors = _errs84;
+                                                                                if (vErrors !== null) {
+                                                                                    if (_errs84) {
+                                                                                        vErrors.length = _errs84;
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors = null;
                                                                                     }
                                                                                 }
-                                                                                if (!valid42) {
-                                                                                    const err88 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(r%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*R)otate%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing10 }, message: "must match exactly one schema in oneOf" };
+                                                                            }
+                                                                            var valid19 = _errs83 === errors;
+                                                                            if (!valid19) {
+                                                                                break;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    if (valid19) {
+                                                                        var valid19 = true;
+                                                                        for (const key8 in data) {
+                                                                            if (pattern4.test(key8)) {
+                                                                                let data21 = data[key8];
+                                                                                const _errs93 = errors;
+                                                                                const _errs94 = errors;
+                                                                                let valid35 = false;
+                                                                                const _errs95 = errors;
+                                                                                const _errs96 = errors;
+                                                                                if (!(((typeof data21 == "number") && (!(data21 % 1) && !isNaN(data21))) && (isFinite(data21)))) {
+                                                                                    const err75 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
                                                                                     if (vErrors === null) {
-                                                                                        vErrors = [err88];
+                                                                                        vErrors = [err75];
                                                                                     }
                                                                                     else {
-                                                                                        vErrors.push(err88);
+                                                                                        vErrors.push(err75);
                                                                                     }
                                                                                     errors++;
-                                                                                    validate10.errors = vErrors;
-                                                                                    return false;
                                                                                 }
-                                                                                else {
-                                                                                    errors = _errs117;
-                                                                                    if (vErrors !== null) {
-                                                                                        if (_errs117) {
-                                                                                            vErrors.length = _errs117;
-                                                                                        }
-                                                                                        else {
-                                                                                            vErrors = null;
+                                                                                if (errors === _errs96) {
+                                                                                    if ((typeof data21 == "number") && (isFinite(data21))) {
+                                                                                        if (data21 < 2 || isNaN(data21)) {
+                                                                                            const err76 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 2 }, message: "must be >= 2" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err76];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err76);
+                                                                                            }
+                                                                                            errors++;
                                                                                         }
                                                                                     }
                                                                                 }
-                                                                                var valid21 = _errs116 === errors;
-                                                                                if (!valid21) {
-                                                                                    break;
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                        if (valid21) {
-                                                                            var valid21 = true;
-                                                                            for (const key10 in data) {
-                                                                                if (pattern7.test(key10)) {
-                                                                                    let data28 = data[key10];
-                                                                                    const _errs126 = errors;
-                                                                                    const _errs127 = errors;
-                                                                                    let valid46 = false;
-                                                                                    let passing11 = null;
-                                                                                    const _errs128 = errors;
-                                                                                    const _errs129 = errors;
-                                                                                    if (errors === _errs129) {
-                                                                                        if ((typeof data28 == "number") && (isFinite(data28))) {
-                                                                                            if (data28 > 100 || isNaN(data28)) {
-                                                                                                const err89 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
+                                                                                var _valid7 = _errs95 === errors;
+                                                                                valid35 = valid35 || _valid7;
+                                                                                if (!valid35) {
+                                                                                    const _errs98 = errors;
+                                                                                    if (errors === _errs98) {
+                                                                                        if (Array.isArray(data21)) {
+                                                                                            if (data21.length > 2) {
+                                                                                                const err77 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/anyOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
                                                                                                 if (vErrors === null) {
-                                                                                                    vErrors = [err89];
+                                                                                                    vErrors = [err77];
                                                                                                 }
                                                                                                 else {
-                                                                                                    vErrors.push(err89);
+                                                                                                    vErrors.push(err77);
                                                                                                 }
                                                                                                 errors++;
                                                                                             }
                                                                                             else {
-                                                                                                if (data28 < -100 || isNaN(data28)) {
-                                                                                                    const err90 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
+                                                                                                if (data21.length < 0) {
+                                                                                                    const err78 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/anyOf/1/minItems", keyword: "minItems", params: { limit: 0 }, message: "must NOT have fewer than 0 items" };
                                                                                                     if (vErrors === null) {
-                                                                                                        vErrors = [err90];
+                                                                                                        vErrors = [err78];
                                                                                                     }
                                                                                                     else {
-                                                                                                        vErrors.push(err90);
+                                                                                                        vErrors.push(err78);
                                                                                                     }
                                                                                                     errors++;
                                                                                                 }
-                                                                                            }
-                                                                                        }
-                                                                                        else {
-                                                                                            const err91 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err91];
-                                                                                            }
-                                                                                            else {
-                                                                                                vErrors.push(err91);
-                                                                                            }
-                                                                                            errors++;
-                                                                                        }
-                                                                                    }
-                                                                                    var _valid11 = _errs128 === errors;
-                                                                                    if (_valid11) {
-                                                                                        valid46 = true;
-                                                                                        passing11 = 0;
-                                                                                    }
-                                                                                    const _errs131 = errors;
-                                                                                    if (errors === _errs131) {
-                                                                                        if (Array.isArray(data28)) {
-                                                                                            if (data28.length > 2) {
-                                                                                                const err92 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateY%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
-                                                                                                if (vErrors === null) {
-                                                                                                    vErrors = [err92];
-                                                                                                }
                                                                                                 else {
-                                                                                                    vErrors.push(err92);
-                                                                                                }
-                                                                                                errors++;
-                                                                                            }
-                                                                                            else {
-                                                                                                var valid48 = true;
-                                                                                                const len11 = data28.length;
-                                                                                                for (let i11 = 0; i11 < len11; i11++) {
-                                                                                                    let data29 = data28[i11];
-                                                                                                    const _errs133 = errors;
-                                                                                                    const _errs134 = errors;
-                                                                                                    if (errors === _errs134) {
-                                                                                                        if ((typeof data29 == "number") && (isFinite(data29))) {
-                                                                                                            if (data29 > 100 || isNaN(data29)) {
-                                                                                                                const err93 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i11, schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
-                                                                                                                if (vErrors === null) {
-                                                                                                                    vErrors = [err93];
-                                                                                                                }
-                                                                                                                else {
-                                                                                                                    vErrors.push(err93);
-                                                                                                                }
-                                                                                                                errors++;
+                                                                                                    var valid37 = true;
+                                                                                                    const len7 = data21.length;
+                                                                                                    for (let i7 = 0; i7 < len7; i7++) {
+                                                                                                        let data22 = data21[i7];
+                                                                                                        const _errs100 = errors;
+                                                                                                        const _errs101 = errors;
+                                                                                                        if (!(((typeof data22 == "number") && (!(data22 % 1) && !isNaN(data22))) && (isFinite(data22)))) {
+                                                                                                            const err79 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i7, schemaPath: "#/definitions/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err79];
                                                                                                             }
                                                                                                             else {
-                                                                                                                if (data29 < -100 || isNaN(data29)) {
-                                                                                                                    const err94 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i11, schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
+                                                                                                                vErrors.push(err79);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                        if (errors === _errs101) {
+                                                                                                            if ((typeof data22 == "number") && (isFinite(data22))) {
+                                                                                                                if (data22 < 2 || isNaN(data22)) {
+                                                                                                                    const err80 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i7, schemaPath: "#/definitions/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 2 }, message: "must be >= 2" };
                                                                                                                     if (vErrors === null) {
-                                                                                                                        vErrors = [err94];
+                                                                                                                        vErrors = [err80];
                                                                                                                     }
                                                                                                                     else {
-                                                                                                                        vErrors.push(err94);
+                                                                                                                        vErrors.push(err80);
                                                                                                                     }
                                                                                                                     errors++;
                                                                                                                 }
                                                                                                             }
                                                                                                         }
-                                                                                                        else {
-                                                                                                            const err95 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i11, schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                                            if (vErrors === null) {
-                                                                                                                vErrors = [err95];
-                                                                                                            }
-                                                                                                            else {
-                                                                                                                vErrors.push(err95);
-                                                                                                            }
-                                                                                                            errors++;
+                                                                                                        var valid37 = _errs100 === errors;
+                                                                                                        if (!valid37) {
+                                                                                                            break;
                                                                                                         }
                                                                                                     }
-                                                                                                    var valid48 = _errs133 === errors;
-                                                                                                    if (!valid48) {
-                                                                                                        break;
-                                                                                                    }
                                                                                                 }
                                                                                             }
                                                                                         }
                                                                                         else {
-                                                                                            const err96 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateY%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                                                            const err81 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/anyOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
                                                                                             if (vErrors === null) {
-                                                                                                vErrors = [err96];
+                                                                                                vErrors = [err81];
                                                                                             }
                                                                                             else {
-                                                                                                vErrors.push(err96);
+                                                                                                vErrors.push(err81);
                                                                                             }
                                                                                             errors++;
                                                                                         }
                                                                                     }
-                                                                                    var _valid11 = _errs131 === errors;
-                                                                                    if (_valid11 && valid46) {
-                                                                                        valid46 = false;
-                                                                                        passing11 = [passing11, 1];
+                                                                                    var _valid7 = _errs98 === errors;
+                                                                                    valid35 = valid35 || _valid7;
+                                                                                }
+                                                                                if (!valid35) {
+                                                                                    const err82 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E%5Ba-z%5D%5Ba-zA-Z0-9%5D*ColorFillStops%24/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err82];
                                                                                     }
                                                                                     else {
-                                                                                        if (_valid11) {
-                                                                                            valid46 = true;
-                                                                                            passing11 = 1;
-                                                                                        }
+                                                                                        vErrors.push(err82);
                                                                                     }
-                                                                                    if (!valid46) {
-                                                                                        const err97 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateY%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing11 }, message: "must match exactly one schema in oneOf" };
-                                                                                        if (vErrors === null) {
-                                                                                            vErrors = [err97];
+                                                                                    errors++;
+                                                                                    validate10.errors = vErrors;
+                                                                                    return false;
+                                                                                }
+                                                                                else {
+                                                                                    errors = _errs94;
+                                                                                    if (vErrors !== null) {
+                                                                                        if (_errs94) {
+                                                                                            vErrors.length = _errs94;
                                                                                         }
                                                                                         else {
-                                                                                            vErrors.push(err97);
+                                                                                            vErrors = null;
                                                                                         }
-                                                                                        errors++;
-                                                                                        validate10.errors = vErrors;
-                                                                                        return false;
                                                                                     }
-                                                                                    else {
-                                                                                        errors = _errs127;
-                                                                                        if (vErrors !== null) {
-                                                                                            if (_errs127) {
-                                                                                                vErrors.length = _errs127;
-                                                                                            }
-                                                                                            else {
-                                                                                                vErrors = null;
-                                                                                            }
-                                                                                        }
+                                                                                }
+                                                                                var valid19 = _errs93 === errors;
+                                                                                if (!valid19) {
+                                                                                    break;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        if (valid19) {
+                                                                            var valid19 = true;
+                                                                            for (const key9 in data) {
+                                                                                if (pattern5.test(key9)) {
+                                                                                    const _errs103 = errors;
+                                                                                    if (!(validate13(data[key9], { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key9, rootData }))) {
+                                                                                        vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                                                                                        errors = vErrors.length;
                                                                                     }
-                                                                                    var valid21 = _errs126 === errors;
-                                                                                    if (!valid21) {
+                                                                                    var valid19 = _errs103 === errors;
+                                                                                    if (!valid19) {
                                                                                         break;
                                                                                     }
                                                                                 }
                                                                             }
-                                                                            if (valid21) {
-                                                                                var valid21 = true;
-                                                                                for (const key11 in data) {
-                                                                                    if (pattern8.test(key11)) {
-                                                                                        let data30 = data[key11];
-                                                                                        const _errs136 = errors;
-                                                                                        const _errs137 = errors;
-                                                                                        let valid50 = false;
-                                                                                        let passing12 = null;
-                                                                                        const _errs138 = errors;
-                                                                                        const _errs139 = errors;
-                                                                                        if (errors === _errs139) {
-                                                                                            if ((typeof data30 == "number") && (isFinite(data30))) {
-                                                                                                if (data30 > 100 || isNaN(data30)) {
-                                                                                                    const err98 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
-                                                                                                    if (vErrors === null) {
-                                                                                                        vErrors = [err98];
-                                                                                                    }
-                                                                                                    else {
-                                                                                                        vErrors.push(err98);
-                                                                                                    }
-                                                                                                    errors++;
-                                                                                                }
-                                                                                                else {
-                                                                                                    if (data30 < -100 || isNaN(data30)) {
-                                                                                                        const err99 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
-                                                                                                        if (vErrors === null) {
-                                                                                                            vErrors = [err99];
-                                                                                                        }
-                                                                                                        else {
-                                                                                                            vErrors.push(err99);
-                                                                                                        }
-                                                                                                        errors++;
-                                                                                                    }
-                                                                                                }
-                                                                                            }
-                                                                                            else {
-                                                                                                const err100 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                                if (vErrors === null) {
-                                                                                                    vErrors = [err100];
-                                                                                                }
-                                                                                                else {
-                                                                                                    vErrors.push(err100);
-                                                                                                }
-                                                                                                errors++;
-                                                                                            }
-                                                                                        }
-                                                                                        var _valid12 = _errs138 === errors;
-                                                                                        if (_valid12) {
-                                                                                            valid50 = true;
-                                                                                            passing12 = 0;
-                                                                                        }
-                                                                                        const _errs141 = errors;
-                                                                                        if (errors === _errs141) {
-                                                                                            if (Array.isArray(data30)) {
-                                                                                                if (data30.length > 2) {
-                                                                                                    const err101 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateX%24/oneOf/1/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
-                                                                                                    if (vErrors === null) {
-                                                                                                        vErrors = [err101];
-                                                                                                    }
-                                                                                                    else {
-                                                                                                        vErrors.push(err101);
-                                                                                                    }
-                                                                                                    errors++;
-                                                                                                }
-                                                                                                else {
-                                                                                                    var valid52 = true;
-                                                                                                    const len12 = data30.length;
-                                                                                                    for (let i12 = 0; i12 < len12; i12++) {
-                                                                                                        let data31 = data30[i12];
-                                                                                                        const _errs143 = errors;
-                                                                                                        const _errs144 = errors;
-                                                                                                        if (errors === _errs144) {
-                                                                                                            if ((typeof data31 == "number") && (isFinite(data31))) {
-                                                                                                                if (data31 > 100 || isNaN(data31)) {
-                                                                                                                    const err102 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i12, schemaPath: "#/definitions/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
-                                                                                                                    if (vErrors === null) {
-                                                                                                                        vErrors = [err102];
-                                                                                                                    }
-                                                                                                                    else {
-                                                                                                                        vErrors.push(err102);
-                                                                                                                    }
-                                                                                                                    errors++;
-                                                                                                                }
-                                                                                                                else {
-                                                                                                                    if (data31 < -100 || isNaN(data31)) {
-                                                                                                                        const err103 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i12, schemaPath: "#/definitions/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
-                                                                                                                        if (vErrors === null) {
-                                                                                                                            vErrors = [err103];
-                                                                                                                        }
-                                                                                                                        else {
-                                                                                                                            vErrors.push(err103);
-                                                                                                                        }
-                                                                                                                        errors++;
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            }
-                                                                                                            else {
-                                                                                                                const err104 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i12, schemaPath: "#/definitions/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
-                                                                                                                if (vErrors === null) {
-                                                                                                                    vErrors = [err104];
-                                                                                                                }
-                                                                                                                else {
-                                                                                                                    vErrors.push(err104);
-                                                                                                                }
-                                                                                                                errors++;
-                                                                                                            }
-                                                                                                        }
-                                                                                                        var valid52 = _errs143 === errors;
-                                                                                                        if (!valid52) {
-                                                                                                            break;
-                                                                                                        }
-                                                                                                    }
-                                                                                                }
-                                                                                            }
-                                                                                            else {
-                                                                                                const err105 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateX%24/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
-                                                                                                if (vErrors === null) {
-                                                                                                    vErrors = [err105];
-                                                                                                }
-                                                                                                else {
-                                                                                                    vErrors.push(err105);
-                                                                                                }
-                                                                                                errors++;
-                                                                                            }
+                                                                            if (valid19) {
+                                                                                var valid19 = true;
+                                                                                for (const key10 in data) {
+                                                                                    if (pattern6.test(key10)) {
+                                                                                        const _errs105 = errors;
+                                                                                        if (!(validate13(data[key10], { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key10, rootData }))) {
+                                                                                            vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                                                                                            errors = vErrors.length;
                                                                                         }
-                                                                                        var _valid12 = _errs141 === errors;
-                                                                                        if (_valid12 && valid50) {
-                                                                                            valid50 = false;
-                                                                                            passing12 = [passing12, 1];
-                                                                                        }
-                                                                                        else {
-                                                                                            if (_valid12) {
-                                                                                                valid50 = true;
-                                                                                                passing12 = 1;
-                                                                                            }
+                                                                                        var valid19 = _errs105 === errors;
+                                                                                        if (!valid19) {
+                                                                                            break;
                                                                                         }
-                                                                                        if (!valid50) {
-                                                                                            const err106 = { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/patternProperties/%5E(t%7C%5Ba-z%5D%5Ba-zA-Z0-9%5D*T)ranslateX%24/oneOf", keyword: "oneOf", params: { passingSchemas: passing12 }, message: "must match exactly one schema in oneOf" };
-                                                                                            if (vErrors === null) {
-                                                                                                vErrors = [err106];
+                                                                                    }
+                                                                                }
+                                                                                if (valid19) {
+                                                                                    var valid19 = true;
+                                                                                    for (const key11 in data) {
+                                                                                        if (pattern7.test(key11)) {
+                                                                                            const _errs107 = errors;
+                                                                                            if (!(validate16(data[key11], { instancePath: instancePath + "/" + key11.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key11, rootData }))) {
+                                                                                                vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
+                                                                                                errors = vErrors.length;
                                                                                             }
-                                                                                            else {
-                                                                                                vErrors.push(err106);
+                                                                                            var valid19 = _errs107 === errors;
+                                                                                            if (!valid19) {
+                                                                                                break;
                                                                                             }
-                                                                                            errors++;
-                                                                                            validate10.errors = vErrors;
-                                                                                            return false;
                                                                                         }
-                                                                                        else {
-                                                                                            errors = _errs137;
-                                                                                            if (vErrors !== null) {
-                                                                                                if (_errs137) {
-                                                                                                    vErrors.length = _errs137;
+                                                                                    }
+                                                                                    if (valid19) {
+                                                                                        var valid19 = true;
+                                                                                        for (const key12 in data) {
+                                                                                            if (pattern8.test(key12)) {
+                                                                                                const _errs109 = errors;
+                                                                                                if (!(validate16(data[key12], { instancePath: instancePath + "/" + key12.replace(/~/g, "~0").replace(/\//g, "~1"), parentData: data, parentDataProperty: key12, rootData }))) {
+                                                                                                    vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
+                                                                                                    errors = vErrors.length;
                                                                                                 }
-                                                                                                else {
-                                                                                                    vErrors = null;
+                                                                                                var valid19 = _errs109 === errors;
+                                                                                                if (!valid19) {
+                                                                                                    break;
                                                                                                 }
                                                                                             }
                                                                                         }
-                                                                                        var valid21 = _errs136 === errors;
-                                                                                        if (!valid21) {
-                                                                                            break;
-                                                                                        }
                                                                                     }
                                                                                 }
                                                                             }