@dicebear/core 9.4.2 → 10.0.0-rc.1

package/lib/Validator/OptionsValidator.js

@@ -0,0 +1,2203 @@
+import { OptionsValidationError } from '../Error/OptionsValidationError.js';
+function ucs2length(str) { let n = 0; for (const _ of str)
+    n++; return n; }
+"use strict";
+const schema31 = { "$id": "https://cdn.hopjs.net/npm/@dicebear/schema@0.9.0/dist/options.min.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "DiceBear options schema", "type": "object", "$defs": { "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": 1 }, "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": "#/$defs/flip" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/fontFamilyName" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/fontWeight" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/scale" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/borderRadius" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/color" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/colorFill" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/colorFillStops" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/rotate" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/rotate" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/translate" }, { "type": "array", "items": { "$ref": "#/$defs/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": "#/$defs/translate" }, { "type": "array", "items": { "$ref": "#/$defs/translate" }, "maxItems": 2 }] } }, "additionalProperties": false };
+const schema32 = { "type": "string", "enum": ["none", "horizontal", "vertical", "both"] };
+const schema34 = { "type": "string", "pattern": "^[a-zA-Z0-9 _\\-]+$" };
+const schema36 = { "type": "integer", "minimum": 1, "maximum": 1000 };
+const schema38 = { "type": "number", "minimum": 0 };
+const schema40 = { "type": "number", "minimum": 0, "maximum": 50 };
+const schema42 = { "type": "string", "pattern": "^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$" };
+const schema44 = { "type": "string", "enum": ["solid", "linear", "radial"] };
+const schema46 = { "type": "integer", "minimum": 1 };
+const schema48 = { "type": "number", "minimum": -360, "maximum": 360 };
+const schema52 = { "type": "number", "minimum": -100, "maximum": 100 };
+const func1 = Object.prototype.hasOwnProperty;
+const func2 = ucs2length;
+const pattern4 = new RegExp("^[a-z][a-zA-Z0-9]*Probability$", "u");
+const pattern5 = new RegExp("^[a-z][a-zA-Z0-9]*Variant$", "u");
+const pattern6 = new RegExp("^[a-z][a-zA-Z0-9]*Color$", "u");
+const pattern7 = new RegExp("^[a-z][a-zA-Z0-9]*ColorFill$", "u");
+const pattern8 = new RegExp("^[a-z][a-zA-Z0-9]*ColorFillStops$", "u");
+const pattern9 = new RegExp("^[a-z][a-zA-Z0-9]*ColorAngle$", "u");
+const pattern10 = new RegExp("^(r|[a-z][a-zA-Z0-9]*R)otate$", "u");
+const pattern11 = new RegExp("^(t|[a-z][a-zA-Z0-9]*T)ranslateY$", "u");
+const pattern12 = new RegExp("^(t|[a-z][a-zA-Z0-9]*T)ranslateX$", "u");
+const pattern13 = new RegExp("^[a-zA-Z0-9 _\\-]+$", "u");
+const pattern17 = new RegExp("^[a-z][a-zA-Z0-9]*$", "u");
+const pattern19 = new RegExp("^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$", "u");
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { /*# sourceURL="https://cdn.hopjs.net/npm/@dicebear/schema@0.9.0/dist/options.min.json" */ ; let vErrors = null; let errors = 0; const evaluated0 = validate20.evaluated; if (evaluated0.dynamicProps) {
+    evaluated0.props = undefined;
+} if (evaluated0.dynamicItems) {
+    evaluated0.items = undefined;
+} if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        const _errs1 = errors;
+        for (const key0 in data) {
+            if (!((((((((((func1.call(schema31.properties, key0)) || (pattern4.test(key0))) || (pattern5.test(key0))) || (pattern6.test(key0))) || (pattern7.test(key0))) || (pattern8.test(key0))) || (pattern9.test(key0))) || (pattern10.test(key0))) || (pattern11.test(key0))) || (pattern12.test(key0)))) {
+                validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+                return false;
+                break;
+            }
+        }
+        if (_errs1 === errors) {
+            if (data.seed !== undefined) {
+                let data0 = data.seed;
+                const _errs2 = errors;
+                if (errors === _errs2) {
+                    if (typeof data0 === "string") {
+                        if (func2(data0) > 1024) {
+                            validate20.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/maxLength", keyword: "maxLength", params: { limit: 1024 }, message: "must NOT have more than 1024 characters" }];
+                            return false;
+                        }
+                    }
+                    else {
+                        validate20.errors = [{ instancePath: instancePath + "/seed", schemaPath: "#/properties/seed/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                        return false;
+                    }
+                }
+                var valid0 = _errs2 === errors;
+            }
+            else {
+                var valid0 = true;
+            }
+            if (valid0) {
+                if (data.size !== undefined) {
+                    let data1 = data.size;
+                    const _errs4 = errors;
+                    if (!(((typeof data1 == "number") && (!(data1 % 1) && !isNaN(data1))) && (isFinite(data1)))) {
+                        validate20.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)) {
+                                validate20.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 {
+                    var valid0 = true;
+                }
+                if (valid0) {
+                    if (data.idRandomization !== undefined) {
+                        const _errs6 = errors;
+                        if (typeof data.idRandomization !== "boolean") {
+                            validate20.errors = [{ instancePath: instancePath + "/idRandomization", schemaPath: "#/properties/idRandomization/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" }];
+                            return false;
+                        }
+                        var valid0 = _errs6 === errors;
+                    }
+                    else {
+                        var valid0 = true;
+                    }
+                    if (valid0) {
+                        if (data.title !== undefined) {
+                            let data3 = data.title;
+                            const _errs8 = errors;
+                            if (errors === _errs8) {
+                                if (typeof data3 === "string") {
+                                    if (func2(data3) > 256) {
+                                        validate20.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/maxLength", keyword: "maxLength", params: { limit: 256 }, message: "must NOT have more than 256 characters" }];
+                                        return false;
+                                    }
+                                }
+                                else {
+                                    validate20.errors = [{ instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                            }
+                            var valid0 = _errs8 === errors;
+                        }
+                        else {
+                            var valid0 = true;
+                        }
+                        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: "#/$defs/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: "#/$defs/flip/enum", keyword: "enum", params: { allowedValues: schema32.enum }, message: "must be equal to one of the allowed values" };
+                                    if (vErrors === null) {
+                                        vErrors = [err1];
+                                    }
+                                    else {
+                                        vErrors.push(err1);
+                                    }
+                                    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: "#/$defs/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: "#/$defs/flip/enum", keyword: "enum", params: { allowedValues: schema32.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" };
+                                        if (vErrors === null) {
+                                            vErrors = [err5];
+                                        }
+                                        else {
+                                            vErrors.push(err5);
+                                        }
+                                        errors++;
+                                    }
+                                }
+                                var _valid0 = _errs15 === errors;
+                                if (_valid0 && valid1) {
+                                    valid1 = false;
+                                    passing0 = [passing0, 1];
+                                }
+                                else {
+                                    if (_valid0) {
+                                        valid1 = true;
+                                        passing0 = 1;
+                                    }
+                                }
+                                if (!valid1) {
+                                    const err6 = { instancePath: instancePath + "/flip", schemaPath: "#/properties/flip/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                                    if (vErrors === null) {
+                                        vErrors = [err6];
+                                    }
+                                    else {
+                                        vErrors.push(err6);
+                                    }
+                                    errors++;
+                                    validate20.errors = vErrors;
+                                    return false;
+                                }
+                                else {
+                                    errors = _errs11;
+                                    if (vErrors !== null) {
+                                        if (_errs11) {
+                                            vErrors.length = _errs11;
+                                        }
+                                        else {
+                                            vErrors = null;
+                                        }
+                                    }
+                                }
+                                var valid0 = _errs10 === errors;
+                            }
+                            else {
+                                var valid0 = true;
+                            }
+                            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 (!pattern13.test(data6)) {
+                                                const err7 = { instancePath: instancePath + "/fontFamily", schemaPath: "#/$defs/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: "#/$defs/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 (!pattern13.test(data7)) {
+                                                                const err10 = { instancePath: instancePath + "/fontFamily/" + i1, schemaPath: "#/$defs/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: "#/$defs/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];
+                                    }
+                                    else {
+                                        if (_valid1) {
+                                            valid5 = true;
+                                            passing1 = 1;
+                                        }
+                                    }
+                                    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];
+                                        }
+                                        else {
+                                            vErrors.push(err13);
+                                        }
+                                        errors++;
+                                        validate20.errors = vErrors;
+                                        return false;
+                                    }
+                                    else {
+                                        errors = _errs21;
+                                        if (vErrors !== null) {
+                                            if (_errs21) {
+                                                vErrors.length = _errs21;
+                                            }
+                                            else {
+                                                vErrors = null;
+                                            }
+                                        }
+                                    }
+                                    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: "#/$defs/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                            if (vErrors === null) {
+                                                vErrors = [err14];
+                                            }
+                                            else {
+                                                vErrors.push(err14);
+                                            }
+                                            errors++;
+                                        }
+                                        if (errors === _errs33) {
+                                            if ((typeof data8 == "number") && (isFinite(data8))) {
+                                                if (data8 > 1000 || isNaN(data8)) {
+                                                    const err15 = { instancePath: instancePath + "/fontWeight", schemaPath: "#/$defs/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: "#/$defs/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err16];
+                                                        }
+                                                        else {
+                                                            vErrors.push(err16);
+                                                        }
+                                                        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: "#/$defs/fontWeight/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err18];
+                                                            }
+                                                            else {
+                                                                vErrors.push(err18);
+                                                            }
+                                                            errors++;
+                                                        }
+                                                        if (errors === _errs38) {
+                                                            if ((typeof data9 == "number") && (isFinite(data9))) {
+                                                                if (data9 > 1000 || isNaN(data9)) {
+                                                                    const err19 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/$defs/fontWeight/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1000 }, message: "must be <= 1000" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err19];
+                                                                    }
+                                                                    else {
+                                                                        vErrors.push(err19);
+                                                                    }
+                                                                    errors++;
+                                                                }
+                                                                else {
+                                                                    if (data9 < 1 || isNaN(data9)) {
+                                                                        const err20 = { instancePath: instancePath + "/fontWeight/" + i2, schemaPath: "#/$defs/fontWeight/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err20];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err20);
+                                                                        }
+                                                                        errors++;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                        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);
+                                                }
+                                                errors++;
+                                            }
+                                        }
+                                        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 (vErrors === null) {
+                                                vErrors = [err22];
+                                            }
+                                            else {
+                                                vErrors.push(err22);
+                                            }
+                                            errors++;
+                                            validate20.errors = vErrors;
+                                            return false;
+                                        }
+                                        else {
+                                            errors = _errs31;
+                                            if (vErrors !== null) {
+                                                if (_errs31) {
+                                                    vErrors.length = _errs31;
+                                                }
+                                                else {
+                                                    vErrors = null;
+                                                }
+                                            }
+                                        }
+                                        var valid0 = _errs30 === errors;
+                                    }
+                                    else {
+                                        var valid0 = 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: "#/$defs/scale/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err23];
+                                                        }
+                                                        else {
+                                                            vErrors.push(err23);
+                                                        }
+                                                        errors++;
+                                                    }
+                                                }
+                                                else {
+                                                    const err24 = { instancePath: instancePath + "/scale", schemaPath: "#/$defs/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);
+                                                        }
+                                                        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: "#/$defs/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: "#/$defs/scale/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err27];
+                                                                    }
+                                                                    else {
+                                                                        vErrors.push(err27);
+                                                                    }
+                                                                    errors++;
+                                                                }
+                                                            }
+                                                            var valid15 = _errs47 === errors;
+                                                            if (!valid15) {
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                else {
+                                                    const err28 = { instancePath: instancePath + "/scale", schemaPath: "#/properties/scale/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err28];
+                                                    }
+                                                    else {
+                                                        vErrors.push(err28);
+                                                    }
+                                                    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++;
+                                                validate20.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: "#/$defs/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: "#/$defs/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: "#/$defs/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" };
+                                                            if (vErrors === null) {
+                                                                vErrors = [err33];
+                                                            }
+                                                            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: "#/$defs/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: "#/$defs/borderRadius/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err35];
+                                                                                }
+                                                                                else {
+                                                                                    vErrors.push(err35);
+                                                                                }
+                                                                                errors++;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    else {
+                                                                        const err36 = { instancePath: instancePath + "/borderRadius/" + i4, schemaPath: "#/$defs/borderRadius/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err36];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err36);
+                                                                        }
+                                                                        errors++;
+                                                                    }
+                                                                }
+                                                                var valid19 = _errs57 === errors;
+                                                                if (!valid19) {
+                                                                    break;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    else {
+                                                        const err37 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/oneOf/1/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                                                        if (vErrors === null) {
+                                                            vErrors = [err37];
+                                                        }
+                                                        else {
+                                                            vErrors.push(err37);
+                                                        }
+                                                        errors++;
+                                                    }
+                                                }
+                                                var _valid4 = _errs55 === errors;
+                                                if (_valid4 && valid17) {
+                                                    valid17 = false;
+                                                    passing4 = [passing4, 1];
+                                                }
+                                                else {
+                                                    if (_valid4) {
+                                                        valid17 = true;
+                                                        passing4 = 1;
+                                                    }
+                                                }
+                                                if (!valid17) {
+                                                    const err38 = { instancePath: instancePath + "/borderRadius", schemaPath: "#/properties/borderRadius/oneOf", keyword: "oneOf", params: { passingSchemas: passing4 }, message: "must match exactly one schema in oneOf" };
+                                                    if (vErrors === null) {
+                                                        vErrors = [err38];
+                                                    }
+                                                    else {
+                                                        vErrors.push(err38);
+                                                    }
+                                                    errors++;
+                                                    validate20.errors = vErrors;
+                                                    return false;
+                                                }
+                                                else {
+                                                    errors = _errs51;
+                                                    if (vErrors !== null) {
+                                                        if (_errs51) {
+                                                            vErrors.length = _errs51;
+                                                        }
+                                                        else {
+                                                            vErrors = null;
+                                                        }
+                                                    }
+                                                }
+                                                var valid0 = _errs50 === errors;
+                                            }
+                                            else {
+                                                var valid0 = true;
+                                            }
+                                            if (valid0) {
+                                                var valid21 = true;
+                                                for (const key1 in data) {
+                                                    if (pattern4.test(key1)) {
+                                                        let data14 = data[key1];
+                                                        const _errs60 = errors;
+                                                        if (errors === _errs60) {
+                                                            if ((typeof data14 == "number") && (isFinite(data14))) {
+                                                                if (data14 > 100 || isNaN(data14)) {
+                                                                    validate20.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;
+                                                                }
+                                                                else {
+                                                                    if (data14 < 0 || isNaN(data14)) {
+                                                                        validate20.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;
+                                                                    }
+                                                                }
+                                                            }
+                                                            else {
+                                                                validate20.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;
+                                                            }
+                                                        }
+                                                        var valid21 = _errs60 === errors;
+                                                        if (!valid21) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                if (valid21) {
+                                                    var valid21 = true;
+                                                    for (const key2 in data) {
+                                                        if (pattern5.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" };
+                                                                if (vErrors === null) {
+                                                                    vErrors = [err39];
+                                                                }
+                                                                else {
+                                                                    vErrors.push(err39);
+                                                                }
+                                                                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" };
+                                                                    if (vErrors === null) {
+                                                                        vErrors = [err42];
+                                                                    }
+                                                                    else {
+                                                                        vErrors.push(err42);
+                                                                    }
+                                                                    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" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err43];
+                                                                            }
+                                                                            else {
+                                                                                vErrors.push(err43);
+                                                                            }
+                                                                            errors++;
+                                                                        }
+                                                                        else {
+                                                                            for (const key3 in data15) {
+                                                                                const _errs72 = errors;
+                                                                                if (typeof key3 === "string") {
+                                                                                    if (!pattern17.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 (vErrors === null) {
+                                                                                        vErrors = [err45];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err45);
+                                                                                    }
+                                                                                    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 {
+                                                                                            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++;
+                                                                                        }
+                                                                                    }
+                                                                                    var valid25 = _errs74 === errors;
+                                                                                    if (!valid25) {
+                                                                                        break;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    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);
+                                                                        }
+                                                                        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++;
+                                                                validate20.errors = vErrors;
+                                                                return false;
+                                                            }
+                                                            else {
+                                                                errors = _errs63;
+                                                                if (vErrors !== null) {
+                                                                    if (_errs63) {
+                                                                        vErrors.length = _errs63;
+                                                                    }
+                                                                    else {
+                                                                        vErrors = null;
+                                                                    }
+                                                                }
+                                                            }
+                                                            var valid21 = _errs62 === errors;
+                                                            if (!valid21) {
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                    if (valid21) {
+                                                        var valid21 = true;
+                                                        for (const key5 in data) {
+                                                            if (pattern6.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 (!pattern19.test(data18)) {
+                                                                            const err50 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/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++;
+                                                                        }
+                                                                    }
+                                                                    else {
+                                                                        const err51 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/color/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err51];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err51);
+                                                                        }
+                                                                        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 (!pattern19.test(data19)) {
+                                                                                            const err53 = { instancePath: instancePath + "/" + key5.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i6, schemaPath: "#/$defs/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: "#/$defs/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" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err55];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err55);
+                                                                        }
+                                                                        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++;
+                                                                    validate20.errors = vErrors;
+                                                                    return false;
+                                                                }
+                                                                else {
+                                                                    errors = _errs77;
+                                                                    if (vErrors !== null) {
+                                                                        if (_errs77) {
+                                                                            vErrors.length = _errs77;
+                                                                        }
+                                                                        else {
+                                                                            vErrors = null;
+                                                                        }
+                                                                    }
+                                                                }
+                                                                var valid21 = _errs76 === errors;
+                                                                if (!valid21) {
+                                                                    break;
+                                                                }
+                                                            }
+                                                        }
+                                                        if (valid21) {
+                                                            var valid21 = true;
+                                                            for (const key6 in data) {
+                                                                if (pattern7.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: "#/$defs/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: "#/$defs/colorFill/enum", keyword: "enum", params: { allowedValues: schema44.enum }, message: "must be equal to one of the allowed values" };
+                                                                        if (vErrors === null) {
+                                                                            vErrors = [err58];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err58);
+                                                                        }
+                                                                        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 {
+                                                                                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: "#/$defs/colorFill/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err60];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err60);
+                                                                                        }
+                                                                                        errors++;
+                                                                                    }
+                                                                                    if (!(((data21 === "solid") || (data21 === "linear")) || (data21 === "radial"))) {
+                                                                                        const err61 = { instancePath: instancePath + "/" + key6.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i7, schemaPath: "#/$defs/colorFill/enum", keyword: "enum", params: { allowedValues: schema44.enum }, message: "must be equal to one of the allowed values" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err61];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err61);
+                                                                                        }
+                                                                                        errors++;
+                                                                                    }
+                                                                                    var valid32 = _errs93 === errors;
+                                                                                    if (!valid32) {
+                                                                                        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 {
+                                                                        if (_valid7) {
+                                                                            valid30 = true;
+                                                                            passing7 = 1;
+                                                                        }
+                                                                    }
+                                                                    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];
+                                                                        }
+                                                                        else {
+                                                                            vErrors.push(err63);
+                                                                        }
+                                                                        errors++;
+                                                                        validate20.errors = vErrors;
+                                                                        return false;
+                                                                    }
+                                                                    else {
+                                                                        errors = _errs87;
+                                                                        if (vErrors !== null) {
+                                                                            if (_errs87) {
+                                                                                vErrors.length = _errs87;
+                                                                            }
+                                                                            else {
+                                                                                vErrors = null;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    var valid21 = _errs86 === errors;
+                                                                    if (!valid21) {
+                                                                        break;
+                                                                    }
+                                                                }
+                                                            }
+                                                            if (valid21) {
+                                                                var valid21 = true;
+                                                                for (const key7 in data) {
+                                                                    if (pattern8.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: "#/$defs/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                                                            if (vErrors === null) {
+                                                                                vErrors = [err64];
+                                                                            }
+                                                                            else {
+                                                                                vErrors.push(err64);
+                                                                            }
+                                                                            errors++;
+                                                                        }
+                                                                        if (errors === _errs99) {
+                                                                            if ((typeof data22 == "number") && (isFinite(data22))) {
+                                                                                if (data22 < 1 || isNaN(data22)) {
+                                                                                    const err65 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err65];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err65);
+                                                                                    }
+                                                                                    errors++;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        var _valid8 = _errs98 === errors;
+                                                                        if (_valid8) {
+                                                                            valid34 = true;
+                                                                            passing8 = 0;
+                                                                        }
+                                                                        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" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err66];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err66);
+                                                                                    }
+                                                                                    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: "#/$defs/colorFillStops/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err67];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err67);
+                                                                                            }
+                                                                                            errors++;
+                                                                                        }
+                                                                                        if (errors === _errs104) {
+                                                                                            if ((typeof data23 == "number") && (isFinite(data23))) {
+                                                                                                if (data23 < 1 || isNaN(data23)) {
+                                                                                                    const err68 = { instancePath: instancePath + "/" + key7.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i8, schemaPath: "#/$defs/colorFillStops/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                                                                                                    if (vErrors === null) {
+                                                                                                        vErrors = [err68];
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        vErrors.push(err68);
+                                                                                                    }
+                                                                                                    errors++;
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        var valid36 = _errs103 === errors;
+                                                                                        if (!valid36) {
+                                                                                            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" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err69];
+                                                                                }
+                                                                                else {
+                                                                                    vErrors.push(err69);
+                                                                                }
+                                                                                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++;
+                                                                            validate20.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 (pattern9.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: "#/$defs/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err71];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err71);
+                                                                                        }
+                                                                                        errors++;
+                                                                                    }
+                                                                                    else {
+                                                                                        if (data24 < -360 || isNaN(data24)) {
+                                                                                            const err72 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err72];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err72);
+                                                                                            }
+                                                                                            errors++;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                else {
+                                                                                    const err73 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err73];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err73);
+                                                                                    }
+                                                                                    errors++;
+                                                                                }
+                                                                            }
+                                                                            var _valid9 = _errs108 === errors;
+                                                                            if (_valid9) {
+                                                                                valid38 = true;
+                                                                                passing9 = 0;
+                                                                            }
+                                                                            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" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err74];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err74);
+                                                                                        }
+                                                                                        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: "#/$defs/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: "#/$defs/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err76];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err76);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                else {
+                                                                                                    const err77 = { instancePath: instancePath + "/" + key8.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i9, schemaPath: "#/$defs/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                    if (vErrors === null) {
+                                                                                                        vErrors = [err77];
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        vErrors.push(err77);
+                                                                                                    }
+                                                                                                    errors++;
+                                                                                                }
+                                                                                            }
+                                                                                            var valid40 = _errs113 === errors;
+                                                                                            if (!valid40) {
+                                                                                                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" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err78];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err78);
+                                                                                    }
+                                                                                    errors++;
+                                                                                }
+                                                                            }
+                                                                            var _valid9 = _errs111 === errors;
+                                                                            if (_valid9 && valid38) {
+                                                                                valid38 = false;
+                                                                                passing9 = [passing9, 1];
+                                                                            }
+                                                                            else {
+                                                                                if (_valid9) {
+                                                                                    valid38 = true;
+                                                                                    passing9 = 1;
+                                                                                }
+                                                                            }
+                                                                            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" };
+                                                                                if (vErrors === null) {
+                                                                                    vErrors = [err79];
+                                                                                }
+                                                                                else {
+                                                                                    vErrors.push(err79);
+                                                                                }
+                                                                                errors++;
+                                                                                validate20.errors = vErrors;
+                                                                                return false;
+                                                                            }
+                                                                            else {
+                                                                                errors = _errs107;
+                                                                                if (vErrors !== null) {
+                                                                                    if (_errs107) {
+                                                                                        vErrors.length = _errs107;
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors = null;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            var valid21 = _errs106 === errors;
+                                                                            if (!valid21) {
+                                                                                break;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    if (valid21) {
+                                                                        var valid21 = true;
+                                                                        for (const key9 in data) {
+                                                                            if (pattern10.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: "#/$defs/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err80];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err80);
+                                                                                            }
+                                                                                            errors++;
+                                                                                        }
+                                                                                        else {
+                                                                                            if (data26 < -360 || isNaN(data26)) {
+                                                                                                const err81 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                                if (vErrors === null) {
+                                                                                                    vErrors = [err81];
+                                                                                                }
+                                                                                                else {
+                                                                                                    vErrors.push(err81);
+                                                                                                }
+                                                                                                errors++;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    else {
+                                                                                        const err82 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/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: "#/$defs/rotate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 360 }, message: "must be <= 360" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err84];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err84);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            if (data27 < -360 || isNaN(data27)) {
+                                                                                                                const err85 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i10, schemaPath: "#/$defs/rotate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -360 }, message: "must be >= -360" };
+                                                                                                                if (vErrors === null) {
+                                                                                                                    vErrors = [err85];
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    vErrors.push(err85);
+                                                                                                                }
+                                                                                                                errors++;
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        const err86 = { instancePath: instancePath + "/" + key9.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i10, schemaPath: "#/$defs/rotate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                        if (vErrors === null) {
+                                                                                                            vErrors = [err86];
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            vErrors.push(err86);
+                                                                                                        }
+                                                                                                        errors++;
+                                                                                                    }
+                                                                                                }
+                                                                                                var valid44 = _errs123 === errors;
+                                                                                                if (!valid44) {
+                                                                                                    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" };
+                                                                                        if (vErrors === null) {
+                                                                                            vErrors = [err87];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err87);
+                                                                                        }
+                                                                                        errors++;
+                                                                                    }
+                                                                                }
+                                                                                var _valid10 = _errs121 === errors;
+                                                                                if (_valid10 && valid42) {
+                                                                                    valid42 = false;
+                                                                                    passing10 = [passing10, 1];
+                                                                                }
+                                                                                else {
+                                                                                    if (_valid10) {
+                                                                                        valid42 = true;
+                                                                                        passing10 = 1;
+                                                                                    }
+                                                                                }
+                                                                                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" };
+                                                                                    if (vErrors === null) {
+                                                                                        vErrors = [err88];
+                                                                                    }
+                                                                                    else {
+                                                                                        vErrors.push(err88);
+                                                                                    }
+                                                                                    errors++;
+                                                                                    validate20.errors = vErrors;
+                                                                                    return false;
+                                                                                }
+                                                                                else {
+                                                                                    errors = _errs117;
+                                                                                    if (vErrors !== null) {
+                                                                                        if (_errs117) {
+                                                                                            vErrors.length = _errs117;
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors = null;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                var valid21 = _errs116 === errors;
+                                                                                if (!valid21) {
+                                                                                    break;
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        if (valid21) {
+                                                                            var valid21 = true;
+                                                                            for (const key10 in data) {
+                                                                                if (pattern11.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: "#/$defs/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
+                                                                                                if (vErrors === null) {
+                                                                                                    vErrors = [err89];
+                                                                                                }
+                                                                                                else {
+                                                                                                    vErrors.push(err89);
+                                                                                                }
+                                                                                                errors++;
+                                                                                            }
+                                                                                            else {
+                                                                                                if (data28 < -100 || isNaN(data28)) {
+                                                                                                    const err90 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
+                                                                                                    if (vErrors === null) {
+                                                                                                        vErrors = [err90];
+                                                                                                    }
+                                                                                                    else {
+                                                                                                        vErrors.push(err90);
+                                                                                                    }
+                                                                                                    errors++;
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        else {
+                                                                                            const err91 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/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: "#/$defs/translate/maximum", keyword: "maximum", params: { comparison: "<=", limit: 100 }, message: "must be <= 100" };
+                                                                                                                if (vErrors === null) {
+                                                                                                                    vErrors = [err93];
+                                                                                                                }
+                                                                                                                else {
+                                                                                                                    vErrors.push(err93);
+                                                                                                                }
+                                                                                                                errors++;
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                if (data29 < -100 || isNaN(data29)) {
+                                                                                                                    const err94 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i11, schemaPath: "#/$defs/translate/minimum", keyword: "minimum", params: { comparison: ">=", limit: -100 }, message: "must be >= -100" };
+                                                                                                                    if (vErrors === null) {
+                                                                                                                        vErrors = [err94];
+                                                                                                                    }
+                                                                                                                    else {
+                                                                                                                        vErrors.push(err94);
+                                                                                                                    }
+                                                                                                                    errors++;
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        else {
+                                                                                                            const err95 = { instancePath: instancePath + "/" + key10.replace(/~/g, "~0").replace(/\//g, "~1") + "/" + i11, schemaPath: "#/$defs/translate/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                                                                                            if (vErrors === null) {
+                                                                                                                vErrors = [err95];
+                                                                                                            }
+                                                                                                            else {
+                                                                                                                vErrors.push(err95);
+                                                                                                            }
+                                                                                                            errors++;
+                                                                                                        }
+                                                                                                    }
+                                                                                                    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" };
+                                                                                            if (vErrors === null) {
+                                                                                                vErrors = [err96];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err96);
+                                                                                            }
+                                                                                            errors++;
+                                                                                        }
+                                                                                    }
+                                                                                    var _valid11 = _errs131 === errors;
+                                                                                    if (_valid11 && valid46) {
+                                                                                        valid46 = false;
+                                                                                        passing11 = [passing11, 1];
+                                                                                    }
+                                                                                    else {
+                                                                                        if (_valid11) {
+                                                                                            valid46 = true;
+                                                                                            passing11 = 1;
+                                                                                        }
+                                                                                    }
+                                                                                    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];
+                                                                                        }
+                                                                                        else {
+                                                                                            vErrors.push(err97);
+                                                                                        }
+                                                                                        errors++;
+                                                                                        validate20.errors = vErrors;
+                                                                                        return false;
+                                                                                    }
+                                                                                    else {
+                                                                                        errors = _errs127;
+                                                                                        if (vErrors !== null) {
+                                                                                            if (_errs127) {
+                                                                                                vErrors.length = _errs127;
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors = null;
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    var valid21 = _errs126 === errors;
+                                                                                    if (!valid21) {
+                                                                                        break;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            if (valid21) {
+                                                                                var valid21 = true;
+                                                                                for (const key11 in data) {
+                                                                                    if (pattern12.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: "#/$defs/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: "#/$defs/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: "#/$defs/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: "#/$defs/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: "#/$defs/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: "#/$defs/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++;
+                                                                                            }
+                                                                                        }
+                                                                                        var _valid12 = _errs141 === errors;
+                                                                                        if (_valid12 && valid50) {
+                                                                                            valid50 = false;
+                                                                                            passing12 = [passing12, 1];
+                                                                                        }
+                                                                                        else {
+                                                                                            if (_valid12) {
+                                                                                                valid50 = true;
+                                                                                                passing12 = 1;
+                                                                                            }
+                                                                                        }
+                                                                                        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];
+                                                                                            }
+                                                                                            else {
+                                                                                                vErrors.push(err106);
+                                                                                            }
+                                                                                            errors++;
+                                                                                            validate20.errors = vErrors;
+                                                                                            return false;
+                                                                                        }
+                                                                                        else {
+                                                                                            errors = _errs137;
+                                                                                            if (vErrors !== null) {
+                                                                                                if (_errs137) {
+                                                                                                    vErrors.length = _errs137;
+                                                                                                }
+                                                                                                else {
+                                                                                                    vErrors = null;
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        var valid21 = _errs136 === errors;
+                                                                                        if (!valid21) {
+                                                                                            break;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate20.errors = vErrors; return errors === 0; }
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+export class OptionsValidator {
+    static validate(data) {
+        if (!validate20(data)) {
+            throw new OptionsValidationError(validate20.errors || []);
+        }
+    }
+}